gitlab-radiator 3.3.9 → 3.3.10

package/public/client.js.LICENSE.txt

@@ -0,0 +1,41 @@
+/*
+object-assign
+(c) Sindre Sorhus
+@license MIT
+*/
+
+/**
+ * @license
+ * Lodash <https://lodash.com/>
+ * Copyright OpenJS Foundation and other contributors <https://openjsf.org/>
+ * Released under MIT license <https://lodash.com/license>
+ * Based on Underscore.js 1.8.3 <http://underscorejs.org/LICENSE>
+ * Copyright Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors
+ */
+
+/** @license React v0.20.2
+ * scheduler.production.min.js
+ *
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+/** @license React v17.0.2
+ * react-dom.production.min.js
+ *
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+/** @license React v17.0.2
+ * react.production.min.js
+ *
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */

package/src/app.js

@@ -1,100 +1,187 @@
-import {basicAuth} from './auth'
-import compression from 'compression'
-import {config} from './config'
-import express from 'express'
-import {fetchOfflineRunners} from './gitlab/runners'
-import http from 'http'
-import lessMiddleware from 'less-middleware'
-import os from 'os'
-import path from 'path'
-import socketIo from 'socket.io'
-import {update} from './gitlab'
-
-const cacheDir = path.join(os.tmpdir(), 'gitlab-radiator-css-cache')
-
-const app = express()
-const httpServer = http.Server(app)
-const socketIoServer = socketIo(httpServer)
+"use strict";
+
+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 _lessMiddleware = _interopRequireDefault(require("less-middleware"));
+
+var _os = _interopRequireDefault(require("os"));
+
+var _path = _interopRequireDefault(require("path"));
+
+var _socket = _interopRequireDefault(require("socket.io"));
+
+var _gitlab = require("./gitlab");
+
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) { symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); } keys.push.apply(keys, symbols); } return keys; }
+
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { (0, _defineProperty2.default)(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
+
+var cacheDir = _path.default.join(_os.default.tmpdir(), 'gitlab-radiator-css-cache');
+
+var app = (0, _express.default)();
+
+var httpServer = _http.default.Server(app);
+
+var socketIoServer = (0, _socket.default)(httpServer);
 
 if (process.env.NODE_ENV !== 'production') {
   // eslint-disable-next-line global-require
-  const {bindDevAssets} = require('./dev-assets')
-  bindDevAssets(app)
+  var _require = require('./dev-assets'),
+      bindDevAssets = _require.bindDevAssets;
+
+  bindDevAssets(app);
 }
 
-app.disable('x-powered-by')
-app.use(lessMiddleware(`${__dirname}/../public`, {
-    dest: cacheDir,
-    preprocess: {
-      less: (src) => {
-        let colorLess = ''
-        Object.keys(config.colors).forEach((stateName) => {
-          colorLess += `@${stateName}-color:${config.colors[stateName]};`
-        })
-        return src + colorLess
-      }
+app.disable('x-powered-by');
+app.use((0, _lessMiddleware.default)("".concat(__dirname, "/../public"), {
+  dest: cacheDir,
+  preprocess: {
+    less: src => {
+      var colorLess = '';
+      Object.keys(_config.config.colors).forEach(stateName => {
+        colorLess += "@".concat(stateName, "-color:").concat(_config.config.colors[stateName], ";");
+      });
+      return src + colorLess;
     }
   }
-))
-app.use(express.static(cacheDir))
-app.use(express.static(`${__dirname}/../public`))
-app.use(compression())
-app.use(basicAuth(config.auth))
-
-httpServer.listen(config.port, () => {
+}));
+app.use(_express.default.static(cacheDir));
+app.use(_express.default.static("".concat(__dirname, "/../public")));
+app.use((0, _compression.default)());
+app.use((0, _auth.basicAuth)(_config.config.auth));
+httpServer.listen(_config.config.port, () => {
   // eslint-disable-next-line no-console
-  console.log(`Listening on port *:${config.port}`)
-})
-
-const globalState = {
+  console.log("Listening on port *:".concat(_config.config.port));
+});
+var globalState = {
   projects: null,
   error: null,
-  zoom: config.zoom,
-  projectsOrder: config.projectsOrder,
-  columns: config.columns,
-  groupSuccessfulProjects: config.groupSuccessfulProjects
+  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);
 }
 
-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 _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);
 }
 
-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})
+function errorIfRunnerOffline() {
+  return _errorIfRunnerOffline.apply(this, arguments);
+}
 
-  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
+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);
 }
 
-runUpdate()
+runUpdate();
 
 function withDate(state) {
-  return {
-    ...state,
+  return _objectSpread(_objectSpread({}, state), {}, {
     now: Date.now()
-  }
-}
+  });
+}

package/src/auth.js

@@ -1,21 +1,33 @@
-import authenticate from 'basic-auth'
+"use strict";
 
-export function basicAuth(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) {
   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
 
-  // eslint-disable-next-line no-console
-  console.log('HTTP basic auth enabled')
+
+  console.log('HTTP basic auth enabled');
   return (req, res, next) => {
-    const {name, pass} = authenticate(req) || {}
+    var _ref = (0, _basicAuth.default)(req) || {},
+        name = _ref.name,
+        pass = _ref.pass;
+
     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,43 +1,59 @@
-import assert from 'assert'
-import fs from 'fs'
-import os from 'os'
-import yaml from 'js-yaml'
-
-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) => {
+"use strict";
+
+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 = validate(_jsYaml.default.load(yamlContent));
+exports.config = config;
+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.existsSync(gitlab.caFile, 'utf-8') ? fs.readFileSync(gitlab.caFile) : undefined,
+    ca: gitlab.caFile && _fs.default.existsSync(gitlab.caFile, 'utf-8') ? _fs.default.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(/^~($|\/|\\)/, `${os.homedir()}$1`)
+  return path.replace(/^~($|\/|\\)/, "".concat(_os.default.homedir(), "$1"));
 }
 
 function validate(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
-}
+  _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;
+}

package/src/gitlab/client.js

@@ -1,27 +1,49 @@
-import axios from 'axios'
-import https from 'https'
-import url from 'url'
+"use strict";
 
-export function gitlabRequest(path, params, gitlab) {
-  return lazyClient(gitlab).get(path, {params})
+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
+  });
 }
 
-const clients = new Map()
+var clients = new Map();
 
 function lazyClient(gitlab) {
-  const gitlabUrl = gitlab.url
+  var 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)) {
-    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)
+    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);
   }
-  return clients.get(gitlabUrl)
-}
+
+  return clients.get(gitlabUrl);
+}