gitlab-radiator 4.4.5 → 5.0.0

package/src/{less.js → less.ts}

@@ -1,11 +1,13 @@
-import {config} from './config.js'
 import fs from 'fs'
 import less from 'less'
 import path from 'path'
+import {config} from './config.ts'
+import type {Config} from './config.ts'
+import type {Request, Response} from 'express'
 
 const filename = path.join('public', 'client.less')
 
-export async function serveLessAsCss(req, res) {
+export async function serveLessAsCss(_req: Request, res: Response) {
   try {
     const source = await fs.promises.readFile(filename, 'utf-8')
     const {css} = await less.render(withColorOverrides(source), {filename})
@@ -17,10 +19,15 @@ export async function serveLessAsCss(req, res) {
   }
 }
 
-function withColorOverrides(source) {
+function withColorOverrides(source: string) {
+  const {colors} = config
+  if (!colors) {
+    return source
+  }
+
   let colorLess = ''
-  Object.keys(config.colors).forEach((stateName) => {
-    colorLess += `@${stateName}-color:${config.colors[stateName]};`
+  Object.keys(colors).forEach((stateName) => {
+    colorLess += `@${stateName}-color:${colors[stateName as keyof Config["colors"]]};`
   })
   return source + colorLess
 }

package/src/auth.js

@@ -1,21 +0,0 @@
-import authenticate from 'basic-auth'
-
-export function basicAuth(auth) {
-  if (!auth || !auth.username || !auth.password) {
-     
-    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,44 +0,0 @@
-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.horizontal = config.horizontal || false
-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,
-    '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 || {}
-
-function expandTilde(path) {
-  return path.replace(/^~($|\/|\\)/, `${os.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
-}

package/src/gitlab/client.js

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

package/src/gitlab/index.js

@@ -1,55 +0,0 @@
-import {fetchLatestPipelines} from './pipelines.js'
-import {fetchProjects} from './projects.js'
-
-export async function update(config) {
-  const projectsWithPipelines = await loadProjectsWithPipelines(config)
-  return projectsWithPipelines
-    .filter(project => project.pipelines.length > 0)
-}
-
-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
-}
-
-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) {
-  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(config) {
-  return pipeline => {
-    if (config.projects && config.projects.excludePipelineStatus) {
-      return !config.projects.excludePipelineStatus.includes(pipeline.status)
-    }
-    return true
-  }
-}

package/src/gitlab/pipelines.js

@@ -1,119 +0,0 @@
-import _ from 'lodash'
-import {gitlabRequest} from './client.js'
-
-export async function fetchLatestPipelines(projectId, gitlab) {
-  const pipelines = await fetchLatestAndMasterPipeline(projectId, gitlab)
-
-  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, config) {
-  const pipelines = await fetchPipelines(projectId, config, {per_page: 100})
-  if (pipelines.length === 0) {
-    return []
-  }
-  const latestPipeline = _.take(pipelines, 1)
-  if (latestPipeline[0].ref === 'master') {
-    return latestPipeline
-  }
-  const latestMasterPipeline = _(pipelines).filter({ref: 'master'}).take(1).value()
-  if (latestMasterPipeline.length > 0) {
-    return latestPipeline.concat(latestMasterPipeline)
-  }
-  const masterPipelines = await fetchPipelines(projectId, config, {per_page: 50, ref: 'master'})
-  return latestPipeline.concat(_.take(masterPipelines, 1))
-}
-
-async function fetchPipelines(projectId, config, options) {
-  const {data: pipelines} = await gitlabRequest(`/projects/${projectId}/pipelines`, options, config)
-  return pipelines.filter(pipeline => pipeline.status !== 'skipped')
-}
-
-async function fetchDownstreamJobs(projectId, pipelineId, config) {
-  const {data: gitlabBridgeJobs} = await gitlabRequest(`/projects/${projectId}/pipelines/${pipelineId}/bridges`, {per_page: 100}, config)
-  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, config)
-    downstreamStages.push(stages.map(stage => ({
-      ...stage,
-      name: `${childPipeline.stage}:${stage.name}`
-    })))
-  }
-  return downstreamStages.flat()
-}
-
-async function fetchJobs(projectId, pipelineId, config) {
-  const {data: gitlabJobs} = await gitlabRequest(`/projects/${projectId}/pipelines/${pipelineId}/jobs?include_retried=true`, {per_page: 100}, config)
-  if (gitlabJobs.length === 0) {
-    return {commit: undefined, stages: []}
-  }
-
-  const commit = findCommit(gitlabJobs)
-  const stages = _(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
-    }))
-    .orderBy('id')
-    .groupBy('stage')
-    .mapValues(mergeRetriedJobs)
-    .mapValues(cleanup)
-    .toPairs()
-    .map(([name, jobs]) => ({name, jobs: _.sortBy(jobs, 'name')}))
-    .value()
-
-  return {
-    commit,
-    stages
-  }
-}
-
-function findCommit(jobs) {
-  const [job] = jobs.filter(j => j.commit)
-  if (!job) {
-    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 cleanup(jobs) {
-  return _(jobs)
-    .map(job => _.omitBy(job, _.isNull))
-    .map(job => _.omit(job, 'stage'))
-    .value()
-}

package/src/gitlab/projects.js

@@ -1,73 +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.flat()
-}
-
-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,
-    tags: (project.tag_list || []).map(t => t.toLowerCase())
-  }
-}
-
-function getGroupName(project) {
-  const pathWithNameSpace = project.path_with_namespace
-  return pathWithNameSpace.split('/')[0]
-}
-
-function includeRegexFilter(config) {
-  return project => {
-    if (config.projects && config.projects.include) {
-      const includeRegex = new RegExp(config.projects.include, "i")
-      return includeRegex.test(project.name)
-    }
-    return true
-  }
-}
-
-function excludeRegexFilter(config) {
-  return project => {
-    if (config.projects && config.projects.exclude) {
-      const excludeRegex = new RegExp(config.projects.exclude, "i")
-      return !excludeRegex.test(project.name)
-    }
-    return true
-  }
-}
-
-function archivedFilter(config) {
-  return project => {
-    if (config.ignoreArchived) {
-      return !project.archived
-    }
-    return true
-  }
-}

package/src/gitlab/runners.js

@@ -1,18 +0,0 @@
-import {gitlabRequest} from './client.js'
-
-export async function fetchOfflineRunners(gitlab) {
-  const runners = await fetchRunners(gitlab)
-  const offline = runners.filter(r => r.status === 'offline')
-  return {
-    offline,
-    totalCount: runners.length
-  }
-}
-
-async function fetchRunners(gitlab) {
-  const {data: runners} = await gitlabRequest('/runners', {}, gitlab)
-  return runners.map(r => ({
-    name: r.description || r.id,
-    status: r.status
-  }))
-}