gitlab-radiator 5.1.0 → 5.2.0

package/public/client.js.LICENSE.txt

@@ -1,43 +0,0 @@
-/**
- * @license React
- * react-dom-client.production.js
- *
- * Copyright (c) Meta Platforms, Inc. and 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
- * react-dom.production.js
- *
- * Copyright (c) Meta Platforms, Inc. and 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
- * react.production.js
- *
- * Copyright (c) Meta Platforms, Inc. and 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
- * scheduler.production.js
- *
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- *
- * This source code is licensed under the MIT license found in the
- * LICENSE file in the root directory of this source tree.
- */
-
-//! moment.js
-
-//! moment.js locale configuration

package/src/app.js

@@ -1,74 +0,0 @@
-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 { serveLessAsCss } from "./less.js";
-import { Server } from 'socket.io';
-import { update } from "./gitlab/index.js";
-const app = express();
-const httpServer = new http.Server(app);
-const socketIoServer = new Server(httpServer);
-if (process.env.NODE_ENV !== 'production' && fs.existsSync('./src/dev-assets.ts')) {
-    const { bindDevAssets } = await import("./dev-assets.js");
-    bindDevAssets(app);
-}
-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, () => {
-    console.log(`Listening on port *:${config.port}`);
-});
-const globalState = {
-    projects: null,
-    error: null,
-    zoom: config.zoom,
-    projectsOrder: config.projectsOrder,
-    columns: config.columns,
-    horizontal: config.horizontal,
-    rotateRunningPipelines: config.rotateRunningPipelines,
-    groupSuccessfulProjects: config.groupSuccessfulProjects
-};
-socketIoServer.on('connection', (socket) => {
-    socket.emit('state', withDate(globalState));
-});
-async function runUpdate() {
-    try {
-        globalState.projects = await update(config.gitlabs, config.rotateRunningPipelines > 0);
-        globalState.error = await errorIfRunnerOffline();
-        socketIoServer.emit('state', withDate(globalState));
-    }
-    catch (error) {
-        const message = error instanceof Error ? error.message : String(error);
-        console.error(message);
-        globalState.error = `Failed to communicate with GitLab API: ${message}`;
-        socketIoServer.emit('state', withDate(globalState));
-    }
-    setTimeout(runUpdate, config.interval);
-}
-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;
-}
-await runUpdate();
-function withDate(state) {
-    return {
-        ...state,
-        now: Date.now()
-    };
-}

package/src/auth.js

@@ -1,18 +0,0 @@
-import authenticate from 'basic-auth';
-export function basicAuth(auth) {
-    if (!auth) {
-        console.log('No authentication configured');
-        return (req, res, next) => next();
-    }
-    console.log('HTTP basic auth enabled');
-    return (req, res, next) => {
-        const { name, pass } = authenticate(req) || {};
-        if (auth.username === name && auth.password === pass) {
-            next();
-        }
-        else {
-            res.setHeader('WWW-Authenticate', 'Basic realm="gitlab-radiator"');
-            res.status(401).end();
-        }
-    };
-}

package/src/config.js

@@ -1,80 +0,0 @@
-import fs from 'fs';
-import os from 'os';
-import yaml from 'js-yaml';
-import { z } from 'zod';
-function expandTilde(path) {
-    return path.replace(/^~($|\/|\\)/, `${os.homedir()}$1`);
-}
-const JobStatusSchema = z.literal(['canceled', 'created', 'failed', 'manual', 'pending', 'running', 'skipped', 'success']);
-const GitlabSchema = z.strictObject({
-    url: z.string().min(1, 'Mandatory gitlab url missing from configuration file'),
-    'access-token': z.string().min(1).optional(),
-    ignoreArchived: z.boolean().default(true),
-    maxNonFailedJobsVisible: z.coerce.number().int().default(999999),
-    branch: z.string().min(1).optional(),
-    caFile: z.string().optional(),
-    offlineRunners: z.literal(['all', 'default', 'none']).default('default'),
-    projects: z.strictObject({
-        excludePipelineStatus: z.array(JobStatusSchema).optional(),
-        include: z.string().min(1).optional(),
-        exclude: z.string().min(1).optional()
-    }).optional()
-}).transform(gitlab => {
-    const accessToken = gitlab['access-token'] || process.env.GITLAB_ACCESS_TOKEN;
-    if (!accessToken) {
-        throw new Error('Mandatory gitlab access token missing from configuration (and none present at GITLAB_ACCESS_TOKEN env variable)');
-    }
-    const { url, ignoreArchived, maxNonFailedJobsVisible, caFile, branch, offlineRunners, projects } = gitlab;
-    const ca = caFile && fs.existsSync(caFile) ? fs.readFileSync(caFile, 'utf-8') : undefined;
-    return {
-        url,
-        ignoreArchived,
-        maxNonFailedJobsVisible,
-        branch,
-        ca,
-        offlineRunners,
-        'access-token': accessToken,
-        projects
-    };
-});
-const OrderSchema = z.literal(['status', 'name', 'id', 'nameWithoutNamespace', 'group']);
-const ConfigSchema = z.strictObject({
-    interval: z.coerce.number().default(10).transform(sec => sec * 1000),
-    port: z.coerce.number().int().default(3000),
-    zoom: z.coerce.number().default(1.0),
-    columns: z.coerce.number().int().default(1),
-    horizontal: z.boolean().default(false),
-    rotateRunningPipelines: z.coerce.number().min(0).default(0).transform(sec => sec * 1000),
-    groupSuccessfulProjects: z.boolean().default(false),
-    projectsOrder: z.array(OrderSchema).default(['name']),
-    gitlabs: z.array(GitlabSchema).min(1, { message: 'Mandatory gitlab properties missing from configuration file' }),
-    colors: z.strictObject({
-        background: z.string(),
-        'created-background': z.string(),
-        'created-text': z.string(),
-        'dark-text': z.string(),
-        'error-message-background': z.string(),
-        'error-message-text': z.string(),
-        'failed-background': z.string(),
-        'failed-text': z.string(),
-        'group-background': z.string(),
-        'light-text': z.string(),
-        'pending-background': z.string(),
-        'pending-text': z.string(),
-        'project-background': z.string(),
-        'running-background': z.string(),
-        'running-text': z.string(),
-        'skipped-background': z.string(),
-        'skipped-text': z.string(),
-        'success-background': z.string(),
-        'success-text': z.string()
-    }).partial().optional(),
-    auth: z.strictObject({
-        username: z.string(),
-        password: z.string()
-    }).optional()
-});
-const configFile = expandTilde(process.env.GITLAB_RADIATOR_CONFIG || '~/.gitlab-radiator.yml');
-const yamlContent = fs.readFileSync(configFile, 'utf8');
-const rawConfig = yaml.load(yamlContent);
-export const config = ConfigSchema.parse(rawConfig);

package/src/dev-assets.js

@@ -1,11 +0,0 @@
-import { createRequire } from 'module';
-import webpack from 'webpack';
-import webpackDevMiddleware from 'webpack-dev-middleware';
-import webpackHotMiddleware from 'webpack-hot-middleware';
-const require = createRequire(import.meta.url);
-export function bindDevAssets(app) {
-    const config = require('../webpack.dev.cjs');
-    const compiler = webpack(config);
-    app.use(webpackDevMiddleware(compiler));
-    app.use(webpackHotMiddleware(compiler));
-}

package/src/gitlab/client.js

@@ -1,20 +0,0 @@
-import axios from 'axios';
-import https from 'https';
-import url from 'url';
-export function gitlabRequest(pathStr, params, gitlab) {
-    return lazyClient(gitlab).get(pathStr, { params: params || {} });
-}
-const clients = new Map();
-function lazyClient(gitlab) {
-    let client = clients.get(gitlab.url);
-    if (!client) {
-        client = axios.create({
-            baseURL: url.resolve(gitlab.url, '/api/v4/'),
-            headers: { 'PRIVATE-TOKEN': gitlab['access-token'] },
-            httpsAgent: new https.Agent({ keepAlive: true, ca: gitlab.ca }),
-            timeout: 30 * 1000
-        });
-        clients.set(gitlab.url, client);
-    }
-    return client;
-}

package/src/gitlab/index.js

@@ -1,49 +0,0 @@
-import { fetchLatestPipelines } from "./pipelines.js";
-import { fetchProjects } from "./projects.js";
-export async function update(gitlabs, prioritizeRunningPipelines) {
-    const projectsWithPipelines = await loadProjectsWithPipelines(gitlabs, prioritizeRunningPipelines);
-    return projectsWithPipelines
-        .filter((project) => project.pipelines.length > 0);
-}
-async function loadProjectsWithPipelines(gitlabs, prioritizeRunningPipelines) {
-    const allProjectsWithPipelines = [];
-    await Promise.all(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, prioritizeRunningPipelines));
-        }
-    }));
-    return allProjectsWithPipelines;
-}
-async function projectWithPipelines(project, gitlab, prioritizeRunningPipelines) {
-    const pipelines = filterOutEmpty(await fetchLatestPipelines(project.id, gitlab, prioritizeRunningPipelines))
-        .filter(excludePipelineStatusFilter(gitlab));
-    const status = defaultBranchStatus(project, pipelines);
-    return {
-        ...project,
-        maxNonFailedJobsVisible: gitlab.maxNonFailedJobsVisible,
-        pipelines,
-        status
-    };
-}
-function defaultBranchStatus(project, pipelines) {
-    const [head] = pipelines
-        .filter(({ ref }) => ref === project.default_branch)
-        .map(({ status }) => status);
-    return head;
-}
-function filterOutEmpty(pipelines) {
-    return pipelines.filter(pipeline => pipeline.stages);
-}
-function excludePipelineStatusFilter(gitlab) {
-    return (pipeline) => {
-        if (gitlab.projects?.excludePipelineStatus) {
-            return !gitlab.projects.excludePipelineStatus.includes(pipeline.status);
-        }
-        return true;
-    };
-}

package/src/gitlab/pipelines.js

@@ -1,125 +0,0 @@
-import { gitlabRequest } from "./client.js";
-export async function fetchLatestPipelines(projectId, gitlab, prioritizeRunningPipelines) {
-    const pipelines = await fetchLatestAndMasterPipeline(projectId, gitlab, prioritizeRunningPipelines);
-    const pipelinesWithStages = [];
-    for (const { id, ref, status } of pipelines) {
-        const { commit, stages } = await fetchJobs(projectId, id, gitlab);
-        const downstreamStages = await fetchDownstreamJobs(projectId, id, gitlab);
-        pipelinesWithStages.push({
-            id,
-            ref,
-            status,
-            commit,
-            stages: stages.concat(downstreamStages)
-        });
-    }
-    return pipelinesWithStages;
-}
-async function fetchLatestAndMasterPipeline(projectId, gitlab, prioritizeRunningPipelines) {
-    const options = {
-        per_page: 100,
-        ...(gitlab.branch ? { ref: gitlab.branch } : {})
-    };
-    const pipelines = await fetchPipelines(projectId, gitlab, options);
-    if (pipelines.length === 0) {
-        return [];
-    }
-    const runningPipelines = pipelines.filter(pipeline => pipeline.status === 'running');
-    if (runningPipelines.length > 1 && prioritizeRunningPipelines) {
-        return runningPipelines;
-    }
-    const latestPipeline = pipelines.slice(0, 1);
-    if (latestPipeline[0].ref === 'master') {
-        return latestPipeline;
-    }
-    const latestMasterPipeline = pipelines.filter(p => p.ref === 'master').slice(0, 1);
-    if (latestMasterPipeline.length > 0) {
-        return latestPipeline.concat(latestMasterPipeline);
-    }
-    const masterPipelines = await fetchPipelines(projectId, gitlab, { per_page: 50, ref: 'master' });
-    return latestPipeline.concat(masterPipelines.slice(0, 1));
-}
-async function fetchPipelines(projectId, gitlab, params) {
-    const { data: pipelines } = await gitlabRequest(`/projects/${projectId}/pipelines`, params, gitlab);
-    return pipelines.filter(pipeline => pipeline.status !== 'skipped');
-}
-async function fetchDownstreamJobs(projectId, pipelineId, gitlab) {
-    const { data: gitlabBridgeJobs } = await gitlabRequest(`/projects/${projectId}/pipelines/${pipelineId}/bridges`, { per_page: 100 }, gitlab);
-    const childPipelines = gitlabBridgeJobs.filter((bridge) => bridge.downstream_pipeline !== null && bridge.downstream_pipeline.status !== 'skipped');
-    const downstreamStages = [];
-    for (const childPipeline of childPipelines) {
-        const { stages } = await fetchJobs(childPipeline.downstream_pipeline.project_id, childPipeline.downstream_pipeline.id, gitlab);
-        downstreamStages.push(stages.map((stage) => ({
-            ...stage,
-            name: `${childPipeline.stage}:${stage.name}`
-        })));
-    }
-    return downstreamStages.flat();
-}
-async function fetchJobs(projectId, pipelineId, gitlab) {
-    const { data: gitlabJobs } = await gitlabRequest(`/projects/${projectId}/pipelines/${pipelineId}/jobs?include_retried=true`, { per_page: 100 }, gitlab);
-    if (gitlabJobs.length === 0) {
-        return { commit: null, stages: [] };
-    }
-    const commit = findCommit(gitlabJobs);
-    // Map jobs and sort by id
-    const mappedJobs = gitlabJobs
-        .map(job => ({
-        id: job.id,
-        status: job.status,
-        stage: job.stage,
-        name: job.name,
-        startedAt: job.started_at,
-        finishedAt: job.finished_at,
-        url: job.web_url
-    }))
-        .sort((a, b) => a.id - b.id);
-    // Group by stage
-    const jobsByStage = new Map();
-    for (const job of mappedJobs) {
-        const stageJobs = jobsByStage.get(job.stage) || [];
-        stageJobs.push(job);
-        jobsByStage.set(job.stage, stageJobs);
-    }
-    // Convert to stages array
-    const stages = Array.from(jobsByStage.entries()).map(([name, jobs]) => ({
-        name,
-        jobs: mergeRetriedJobs(removeStageProperty(jobs)).sort(byName)
-    }));
-    return {
-        commit,
-        stages
-    };
-}
-function byName(a, b) {
-    return a.name.localeCompare(b.name);
-}
-function findCommit(jobs) {
-    const [job] = jobs.filter(j => j.commit);
-    if (!job || !job.commit) {
-        return null;
-    }
-    return {
-        title: job.commit.title,
-        author: job.commit.author_name
-    };
-}
-function mergeRetriedJobs(jobs) {
-    return jobs.reduce((mergedJobs, job) => {
-        const index = mergedJobs.findIndex(mergedJob => mergedJob.name === job.name);
-        if (index >= 0) {
-            mergedJobs[index] = job;
-        }
-        else {
-            mergedJobs.push(job);
-        }
-        return mergedJobs;
-    }, []);
-}
-function removeStageProperty(jobs) {
-    return jobs.map(job => {
-        // eslint-disable-next-line @typescript-eslint/no-unused-vars
-        const { stage, ...rest } = job;
-        return rest;
-    });
-}

package/src/gitlab/projects.js

@@ -1,65 +0,0 @@
-import { gitlabRequest } from "./client.js";
-export async function fetchProjects(gitlab) {
-    const projects = await fetchOwnProjects(gitlab);
-    return projects
-        // Ignore projects for which CI/CD is not enabled
-        .filter(project => project.jobs_enabled)
-        .map(projectMapper)
-        .filter(includeRegexFilter(gitlab))
-        .filter(excludeRegexFilter(gitlab))
-        .filter(archivedFilter(gitlab));
-}
-async function fetchOwnProjects(gitlab) {
-    const projects = [];
-    const SAFETY_MAX_PAGE = 10;
-    for (let page = 1; page <= SAFETY_MAX_PAGE; page += 1) {
-        const { data, headers } = await gitlabRequest('/projects', { page, per_page: 100, membership: true }, gitlab);
-        projects.push(...data);
-        if (data.length === 0 || !headers['x-next-page']) {
-            break;
-        }
-    }
-    return projects;
-}
-function projectMapper(project) {
-    return {
-        id: project.id,
-        name: project.path_with_namespace,
-        nameWithoutNamespace: project.path,
-        group: getGroupName(project),
-        archived: project.archived,
-        default_branch: project.default_branch || 'master',
-        url: project.web_url,
-        topics: (project.topics || []).map((t) => t.toLowerCase())
-    };
-}
-function getGroupName(project) {
-    const pathWithNameSpace = project.path_with_namespace;
-    return pathWithNameSpace.split('/')[0];
-}
-function includeRegexFilter(gitlab) {
-    return (project) => {
-        if (gitlab.projects?.include) {
-            const includeRegex = new RegExp(gitlab.projects.include, "i");
-            return includeRegex.test(project.name);
-        }
-        return true;
-    };
-}
-function excludeRegexFilter(gitlab) {
-    return (project) => {
-        if (gitlab.projects?.exclude) {
-            const excludeRegex = new RegExp(gitlab.projects.exclude, "i");
-            return !excludeRegex.test(project.name);
-        }
-        return true;
-    };
-}
-function archivedFilter(gitlab) {
-    return (project) => {
-        if (gitlab.ignoreArchived) {
-            return !project.archived;
-        }
-        return true;
-    };
-}

package/src/gitlab/runners.js

@@ -1,23 +0,0 @@
-import { gitlabRequest } from "./client.js";
-export async function fetchOfflineRunners(gitlab) {
-    if (gitlab.offlineRunners === 'none') {
-        return {
-            offline: [],
-            totalCount: 0
-        };
-    }
-    const runners = await fetchRunners(gitlab);
-    const offline = runners.filter(r => r.status === 'offline');
-    return {
-        offline,
-        totalCount: runners.length
-    };
-}
-async function fetchRunners(gitlab) {
-    const runnersApi = gitlab.offlineRunners === 'all' ? '/runners/all' : '/runners';
-    const { data: runners } = await gitlabRequest(runnersApi, null, gitlab);
-    return runners.map(r => ({
-        name: r.description || r.id.toString(),
-        status: r.status
-    }));
-}

package/src/less.js

@@ -1,28 +0,0 @@
-import fs from 'fs';
-import less from 'less';
-import path from 'path';
-import { config } from "./config.js";
-const filename = path.join('public', 'client.less');
-export async function serveLessAsCss(_req, res) {
-    try {
-        const source = await fs.promises.readFile(filename, 'utf-8');
-        const { css } = await less.render(withColorOverrides(source), { filename });
-        res.setHeader('content-type', 'text/css');
-        res.send(css);
-    }
-    catch (err) {
-        console.error('Failed to render client.less', err);
-        res.sendStatus(500);
-    }
-}
-function withColorOverrides(source) {
-    const { colors } = config;
-    if (!colors) {
-        return source;
-    }
-    let colorLess = '';
-    Object.keys(colors).forEach((stateName) => {
-        colorLess += `@${stateName}-color:${colors[stateName]};`;
-    });
-    return source + colorLess;
-}

package/src/tsconfig.build.tsbuildinfo

@@ -1 +0,0 @@
-{"root":["../../src/app.ts","../../src/auth.ts","../../src/config.ts","../../src/dev-assets.ts","../../src/less.ts","../../src/common/gitlab-types.d.ts","../../src/gitlab/client.ts","../../src/gitlab/index.ts","../../src/gitlab/pipelines.ts","../../src/gitlab/projects.ts","../../src/gitlab/runners.ts"],"version":"5.9.3"}