mirror docker/metadata-action@v4
This commit is contained in:
action-mirror
@@ -0,0 +1,73 @@
|
||||
import * as core from '@actions/core';
|
||||
import {Context} from '@actions/github/lib/context';
|
||||
import {Util} from '@docker/actions-toolkit/lib/util';
|
||||
import {Git} from '@docker/actions-toolkit/lib/git';
|
||||
import {GitHub} from '@docker/actions-toolkit/lib/github';
|
||||
|
||||
export interface Inputs {
|
||||
context: ContextSource;
|
||||
images: string[];
|
||||
tags: string[];
|
||||
flavor: string[];
|
||||
labels: string[];
|
||||
sepTags: string;
|
||||
sepLabels: string;
|
||||
bakeTarget: string;
|
||||
githubToken: string;
|
||||
}
|
||||
|
||||
export function getInputs(): Inputs {
|
||||
return {
|
||||
context: (core.getInput('context') || ContextSource.workflow) as ContextSource,
|
||||
images: Util.getInputList('images', {ignoreComma: true, comment: '#'}),
|
||||
tags: Util.getInputList('tags', {ignoreComma: true, comment: '#'}),
|
||||
flavor: Util.getInputList('flavor', {ignoreComma: true, comment: '#'}),
|
||||
labels: Util.getInputList('labels', {ignoreComma: true, comment: '#'}),
|
||||
sepTags: core.getInput('sep-tags', {trimWhitespace: false}) || `\n`,
|
||||
sepLabels: core.getInput('sep-labels', {trimWhitespace: false}) || `\n`,
|
||||
bakeTarget: core.getInput('bake-target') || `docker-metadata-action`,
|
||||
githubToken: core.getInput('github-token')
|
||||
};
|
||||
}
|
||||
|
||||
export enum ContextSource {
|
||||
workflow = 'workflow',
|
||||
git = 'git'
|
||||
}
|
||||
|
||||
export async function getContext(source: ContextSource): Promise<Context> {
|
||||
switch (source) {
|
||||
case ContextSource.workflow:
|
||||
return getContextFromWorkflow();
|
||||
case ContextSource.git:
|
||||
return await getContextFromGit();
|
||||
default:
|
||||
throw new Error(`Invalid context source: ${source}`);
|
||||
}
|
||||
}
|
||||
|
||||
function getContextFromWorkflow(): Context {
|
||||
const context = GitHub.context;
|
||||
|
||||
// Needs to override Git reference with pr ref instead of upstream branch ref
|
||||
// for pull_request_target event
|
||||
// https://docs.github.com/en/actions/using-workflows/events-that-trigger-workflows#pull_request_target
|
||||
if (/pull_request_target/.test(context.eventName)) {
|
||||
context.ref = `refs/pull/${context.payload.number}/merge`;
|
||||
}
|
||||
|
||||
// DOCKER_METADATA_PR_HEAD_SHA env var can be used to set associated head
|
||||
// SHA instead of commit SHA that triggered the workflow on pull request
|
||||
// event.
|
||||
if (/true/i.test(process.env.DOCKER_METADATA_PR_HEAD_SHA || '')) {
|
||||
if ((/pull_request/.test(context.eventName) || /pull_request_target/.test(context.eventName)) && context.payload?.pull_request?.head?.sha != undefined) {
|
||||
context.sha = context.payload.pull_request.head.sha;
|
||||
}
|
||||
}
|
||||
|
||||
return context;
|
||||
}
|
||||
|
||||
async function getContextFromGit(): Promise<Context> {
|
||||
return await Git.context();
|
||||
}
|
||||
@@ -0,0 +1,87 @@
|
||||
import {parse} from 'csv-parse/sync';
|
||||
import * as core from '@actions/core';
|
||||
|
||||
export interface Flavor {
|
||||
latest: string;
|
||||
prefix: string;
|
||||
prefixLatest: boolean;
|
||||
suffix: string;
|
||||
suffixLatest: boolean;
|
||||
}
|
||||
|
||||
export function Transform(inputs: string[]): Flavor {
|
||||
const flavor: Flavor = {
|
||||
latest: 'auto',
|
||||
prefix: '',
|
||||
prefixLatest: false,
|
||||
suffix: '',
|
||||
suffixLatest: false
|
||||
};
|
||||
|
||||
for (const input of inputs) {
|
||||
const fields = parse(input, {
|
||||
relaxColumnCount: true,
|
||||
skipEmptyLines: true
|
||||
})[0];
|
||||
let onlatestfor = '';
|
||||
for (const field of fields) {
|
||||
const parts = field
|
||||
.toString()
|
||||
.split('=')
|
||||
.map(item => item.trim());
|
||||
if (parts.length == 1) {
|
||||
throw new Error(`Invalid flavor entry: ${input}`);
|
||||
}
|
||||
const key = parts[0].toLowerCase();
|
||||
const value = parts[1];
|
||||
switch (key) {
|
||||
case 'latest': {
|
||||
flavor.latest = value;
|
||||
if (!['auto', 'true', 'false'].includes(flavor.latest)) {
|
||||
throw new Error(`Invalid latest flavor entry: ${input}`);
|
||||
}
|
||||
break;
|
||||
}
|
||||
case 'prefix': {
|
||||
flavor.prefix = value;
|
||||
onlatestfor = 'prefix';
|
||||
break;
|
||||
}
|
||||
case 'suffix': {
|
||||
flavor.suffix = value;
|
||||
onlatestfor = 'suffix';
|
||||
break;
|
||||
}
|
||||
case 'onlatest': {
|
||||
if (!['true', 'false'].includes(value)) {
|
||||
throw new Error(`Invalid value for onlatest attribute: ${value}`);
|
||||
}
|
||||
switch (onlatestfor) {
|
||||
case 'prefix': {
|
||||
flavor.prefixLatest = /true/i.test(value);
|
||||
break;
|
||||
}
|
||||
case 'suffix': {
|
||||
flavor.suffixLatest = /true/i.test(value);
|
||||
break;
|
||||
}
|
||||
}
|
||||
break;
|
||||
}
|
||||
default: {
|
||||
throw new Error(`Unknown flavor entry: ${input}`);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
core.startGroup(`Processing flavor input`);
|
||||
core.info(`latest=${flavor.latest}`);
|
||||
core.info(`prefix=${flavor.prefix}`);
|
||||
core.info(`prefixLatest=${flavor.prefixLatest}`);
|
||||
core.info(`suffix=${flavor.suffix}`);
|
||||
core.info(`suffixLatest=${flavor.suffixLatest}`);
|
||||
core.endGroup();
|
||||
|
||||
return flavor;
|
||||
}
|
||||
@@ -0,0 +1,86 @@
|
||||
import {parse} from 'csv-parse/sync';
|
||||
import * as core from '@actions/core';
|
||||
|
||||
export interface Image {
|
||||
name: string;
|
||||
enable: boolean;
|
||||
}
|
||||
|
||||
export function Transform(inputs: string[]): Image[] {
|
||||
let images: Image[] = [];
|
||||
|
||||
// backward compatibility with old format
|
||||
if (inputs.length == 1) {
|
||||
let newformat = false;
|
||||
const fields = parse(inputs[0], {
|
||||
relaxColumnCount: true,
|
||||
skipEmptyLines: true
|
||||
})[0];
|
||||
for (const field of fields) {
|
||||
const parts = field
|
||||
.toString()
|
||||
.split('=')
|
||||
.map(item => item.trim());
|
||||
if (parts.length == 1) {
|
||||
images.push({name: parts[0], enable: true});
|
||||
} else {
|
||||
newformat = true;
|
||||
break;
|
||||
}
|
||||
}
|
||||
if (!newformat) {
|
||||
return output(images);
|
||||
}
|
||||
}
|
||||
|
||||
images = [];
|
||||
for (const input of inputs) {
|
||||
const image: Image = {name: '', enable: true};
|
||||
const fields = parse(input, {
|
||||
relaxColumnCount: true,
|
||||
skipEmptyLines: true
|
||||
})[0];
|
||||
for (const field of fields) {
|
||||
const parts = field
|
||||
.toString()
|
||||
.split('=')
|
||||
.map(item => item.trim());
|
||||
if (parts.length == 1) {
|
||||
image.name = parts[0];
|
||||
} else {
|
||||
const key = parts[0].toLowerCase();
|
||||
const value = parts[1];
|
||||
switch (key) {
|
||||
case 'name': {
|
||||
image.name = value;
|
||||
break;
|
||||
}
|
||||
case 'enable': {
|
||||
if (!['true', 'false'].includes(value)) {
|
||||
throw new Error(`Invalid enable attribute value: ${input}`);
|
||||
}
|
||||
image.enable = /true/i.test(value);
|
||||
break;
|
||||
}
|
||||
default: {
|
||||
throw new Error(`Unknown image attribute: ${input}`);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
if (image.name.length == 0) {
|
||||
throw new Error(`Image name attribute empty: ${input}`);
|
||||
}
|
||||
images.push(image);
|
||||
}
|
||||
return output(images);
|
||||
}
|
||||
|
||||
function output(images: Image[]): Image[] {
|
||||
core.startGroup(`Processing images input`);
|
||||
for (const image of images) {
|
||||
core.info(`name=${image.name},enable=${image.enable}`);
|
||||
}
|
||||
core.endGroup();
|
||||
return images;
|
||||
}
|
||||
+91
@@ -0,0 +1,91 @@
|
||||
import * as fs from 'fs';
|
||||
import * as core from '@actions/core';
|
||||
import * as actionsToolkit from '@docker/actions-toolkit';
|
||||
import {Toolkit} from '@docker/actions-toolkit/lib/toolkit';
|
||||
|
||||
import {getContext, getInputs, Inputs} from './context';
|
||||
import {Meta, Version} from './meta';
|
||||
|
||||
function setOutput(name: string, value: string) {
|
||||
core.setOutput(name, value);
|
||||
core.exportVariable(`DOCKER_METADATA_OUTPUT_${name.replace(/\W/g, '_').toUpperCase()}`, value);
|
||||
}
|
||||
|
||||
actionsToolkit.run(
|
||||
// main
|
||||
async () => {
|
||||
const inputs: Inputs = getInputs();
|
||||
if (inputs.images.length == 0) {
|
||||
throw new Error(`images input required`);
|
||||
}
|
||||
|
||||
const toolkit = new Toolkit({githubToken: inputs.githubToken});
|
||||
const context = await getContext(inputs.context);
|
||||
const repo = await toolkit.github.repoData();
|
||||
|
||||
await core.group(`Context info`, async () => {
|
||||
core.info(`eventName: ${context.eventName}`);
|
||||
core.info(`sha: ${context.sha}`);
|
||||
core.info(`ref: ${context.ref}`);
|
||||
core.info(`workflow: ${context.workflow}`);
|
||||
core.info(`action: ${context.action}`);
|
||||
core.info(`actor: ${context.actor}`);
|
||||
core.info(`runNumber: ${context.runNumber}`);
|
||||
core.info(`runId: ${context.runId}`);
|
||||
});
|
||||
|
||||
if (core.isDebug()) {
|
||||
await core.group(`Webhook payload`, async () => {
|
||||
core.info(JSON.stringify(context.payload, null, 2));
|
||||
});
|
||||
}
|
||||
|
||||
const meta: Meta = new Meta(inputs, context, repo);
|
||||
|
||||
const version: Version = meta.version;
|
||||
if (meta.version.main == undefined || meta.version.main.length == 0) {
|
||||
core.warning(`No Docker image version has been generated. Check tags input.`);
|
||||
} else {
|
||||
await core.group(`Docker image version`, async () => {
|
||||
core.info(version.main || '');
|
||||
});
|
||||
}
|
||||
setOutput('version', version.main || '');
|
||||
|
||||
// Docker tags
|
||||
const tags: Array<string> = meta.getTags();
|
||||
if (tags.length == 0) {
|
||||
core.warning('No Docker tag has been generated. Check tags input.');
|
||||
} else {
|
||||
await core.group(`Docker tags`, async () => {
|
||||
for (const tag of tags) {
|
||||
core.info(tag);
|
||||
}
|
||||
});
|
||||
}
|
||||
setOutput('tags', tags.join(inputs.sepTags));
|
||||
|
||||
// Docker labels
|
||||
const labels: Array<string> = meta.getLabels();
|
||||
await core.group(`Docker labels`, async () => {
|
||||
for (const label of labels) {
|
||||
core.info(label);
|
||||
}
|
||||
setOutput('labels', labels.join(inputs.sepLabels));
|
||||
});
|
||||
|
||||
// JSON
|
||||
const jsonOutput = meta.getJSON();
|
||||
await core.group(`JSON output`, async () => {
|
||||
core.info(JSON.stringify(jsonOutput, null, 2));
|
||||
setOutput('json', JSON.stringify(jsonOutput));
|
||||
});
|
||||
|
||||
// Bake file definition
|
||||
const bakeFile: string = meta.getBakeFile();
|
||||
await core.group(`Bake file definition`, async () => {
|
||||
core.info(fs.readFileSync(bakeFile, 'utf8'));
|
||||
setOutput('bake-file', bakeFile);
|
||||
});
|
||||
}
|
||||
);
|
||||
+536
@@ -0,0 +1,536 @@
|
||||
import * as handlebars from 'handlebars';
|
||||
import * as fs from 'fs';
|
||||
import * as path from 'path';
|
||||
import moment from 'moment-timezone';
|
||||
import * as pep440 from '@renovate/pep440';
|
||||
import * as semver from 'semver';
|
||||
import * as core from '@actions/core';
|
||||
import {Context} from '@actions/github/lib/context';
|
||||
import {Context as ToolkitContext} from '@docker/actions-toolkit/lib/context';
|
||||
import {GitHubRepo} from '@docker/actions-toolkit/lib/types/github';
|
||||
|
||||
import {Inputs} from './context';
|
||||
import * as icl from './image';
|
||||
import * as tcl from './tag';
|
||||
import * as fcl from './flavor';
|
||||
|
||||
export interface Version {
|
||||
main: string | undefined;
|
||||
partial: string[];
|
||||
latest: boolean | undefined;
|
||||
}
|
||||
|
||||
export class Meta {
|
||||
public readonly version: Version;
|
||||
|
||||
private readonly inputs: Inputs;
|
||||
private readonly context: Context;
|
||||
private readonly repo: GitHubRepo;
|
||||
private readonly images: icl.Image[];
|
||||
private readonly tags: tcl.Tag[];
|
||||
private readonly flavor: fcl.Flavor;
|
||||
private readonly date: Date;
|
||||
|
||||
constructor(inputs: Inputs, context: Context, repo: GitHubRepo) {
|
||||
this.inputs = inputs;
|
||||
this.context = context;
|
||||
this.repo = repo;
|
||||
this.images = icl.Transform(inputs.images);
|
||||
this.tags = tcl.Transform(inputs.tags);
|
||||
this.flavor = fcl.Transform(inputs.flavor);
|
||||
this.date = new Date();
|
||||
this.version = this.getVersion();
|
||||
}
|
||||
|
||||
private getVersion(): Version {
|
||||
let version: Version = {
|
||||
main: undefined,
|
||||
partial: [],
|
||||
latest: undefined
|
||||
};
|
||||
|
||||
for (const tag of this.tags) {
|
||||
const enabled = this.setGlobalExp(tag.attrs['enable']);
|
||||
if (!['true', 'false'].includes(enabled)) {
|
||||
throw new Error(`Invalid value for enable attribute: ${enabled}`);
|
||||
}
|
||||
if (!/true/i.test(enabled)) {
|
||||
continue;
|
||||
}
|
||||
switch (tag.type) {
|
||||
case tcl.Type.Schedule: {
|
||||
version = this.procSchedule(version, tag);
|
||||
break;
|
||||
}
|
||||
case tcl.Type.Semver: {
|
||||
version = this.procSemver(version, tag);
|
||||
break;
|
||||
}
|
||||
case tcl.Type.Pep440: {
|
||||
version = this.procPep440(version, tag);
|
||||
break;
|
||||
}
|
||||
case tcl.Type.Match: {
|
||||
version = this.procMatch(version, tag);
|
||||
break;
|
||||
}
|
||||
case tcl.Type.Ref: {
|
||||
if (tag.attrs['event'] == tcl.RefEvent.Branch) {
|
||||
version = this.procRefBranch(version, tag);
|
||||
} else if (tag.attrs['event'] == tcl.RefEvent.Tag) {
|
||||
version = this.procRefTag(version, tag);
|
||||
} else if (tag.attrs['event'] == tcl.RefEvent.PR) {
|
||||
version = this.procRefPr(version, tag);
|
||||
}
|
||||
break;
|
||||
}
|
||||
case tcl.Type.Edge: {
|
||||
version = this.procEdge(version, tag);
|
||||
break;
|
||||
}
|
||||
case tcl.Type.Raw: {
|
||||
version = this.procRaw(version, tag);
|
||||
break;
|
||||
}
|
||||
case tcl.Type.Sha: {
|
||||
version = this.procSha(version, tag);
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
version.partial = version.partial.filter((item, index) => version.partial.indexOf(item) === index);
|
||||
if (version.latest == undefined) {
|
||||
version.latest = false;
|
||||
}
|
||||
|
||||
return version;
|
||||
}
|
||||
|
||||
private procSchedule(version: Version, tag: tcl.Tag): Version {
|
||||
if (!/schedule/.test(this.context.eventName)) {
|
||||
return version;
|
||||
}
|
||||
|
||||
const currentDate = this.date;
|
||||
const vraw = this.setValue(
|
||||
handlebars.compile(tag.attrs['pattern'])({
|
||||
date: function (format, options) {
|
||||
const m = moment(currentDate);
|
||||
let tz = 'UTC';
|
||||
Object.keys(options.hash).forEach(key => {
|
||||
switch (key) {
|
||||
case 'tz':
|
||||
tz = options.hash[key];
|
||||
break;
|
||||
default:
|
||||
throw new Error(`Unknown ${key} attribute`);
|
||||
}
|
||||
});
|
||||
return m.tz(tz).format(format);
|
||||
}
|
||||
}),
|
||||
tag
|
||||
);
|
||||
|
||||
return Meta.setVersion(version, vraw, this.flavor.latest == 'auto' ? false : this.flavor.latest == 'true');
|
||||
}
|
||||
|
||||
private procSemver(version: Version, tag: tcl.Tag): Version {
|
||||
if (!/^refs\/tags\//.test(this.context.ref) && tag.attrs['value'].length == 0) {
|
||||
return version;
|
||||
}
|
||||
|
||||
let vraw: string;
|
||||
if (tag.attrs['value'].length > 0) {
|
||||
vraw = this.setGlobalExp(tag.attrs['value']);
|
||||
} else {
|
||||
vraw = this.context.ref.replace(/^refs\/tags\//g, '').replace(/\//g, '-');
|
||||
}
|
||||
if (!semver.valid(vraw)) {
|
||||
core.warning(`${vraw} is not a valid semver. More info: https://semver.org/`);
|
||||
return version;
|
||||
}
|
||||
|
||||
let latest = false;
|
||||
const sver = semver.parse(vraw, {
|
||||
loose: true
|
||||
});
|
||||
if (semver.prerelease(vraw)) {
|
||||
if (Meta.isRawStatement(tag.attrs['pattern'])) {
|
||||
vraw = this.setValue(handlebars.compile(tag.attrs['pattern'])(sver), tag);
|
||||
} else {
|
||||
vraw = this.setValue(handlebars.compile('{{version}}')(sver), tag);
|
||||
}
|
||||
} else {
|
||||
vraw = this.setValue(handlebars.compile(tag.attrs['pattern'])(sver), tag);
|
||||
latest = true;
|
||||
}
|
||||
|
||||
return Meta.setVersion(version, vraw, this.flavor.latest == 'auto' ? latest : this.flavor.latest == 'true');
|
||||
}
|
||||
|
||||
private procPep440(version: Version, tag: tcl.Tag): Version {
|
||||
if (!/^refs\/tags\//.test(this.context.ref) && tag.attrs['value'].length == 0) {
|
||||
return version;
|
||||
}
|
||||
|
||||
let vraw: string;
|
||||
if (tag.attrs['value'].length > 0) {
|
||||
vraw = this.setGlobalExp(tag.attrs['value']);
|
||||
} else {
|
||||
vraw = this.context.ref.replace(/^refs\/tags\//g, '').replace(/\//g, '-');
|
||||
}
|
||||
if (!pep440.valid(vraw)) {
|
||||
core.warning(`${vraw} does not conform to PEP 440. More info: https://www.python.org/dev/peps/pep-0440`);
|
||||
return version;
|
||||
}
|
||||
|
||||
let latest = false;
|
||||
const pver = pep440.explain(vraw);
|
||||
if (pver.is_prerelease || pver.is_postrelease || pver.is_devrelease) {
|
||||
if (Meta.isRawStatement(tag.attrs['pattern'])) {
|
||||
vraw = this.setValue(vraw, tag);
|
||||
} else {
|
||||
vraw = this.setValue(pep440.clean(vraw), tag);
|
||||
}
|
||||
} else {
|
||||
vraw = this.setValue(
|
||||
handlebars.compile(tag.attrs['pattern'])({
|
||||
raw: function () {
|
||||
return vraw;
|
||||
},
|
||||
version: function () {
|
||||
return pep440.clean(vraw);
|
||||
},
|
||||
major: function () {
|
||||
return pep440.major(vraw);
|
||||
},
|
||||
minor: function () {
|
||||
return pep440.minor(vraw);
|
||||
},
|
||||
patch: function () {
|
||||
return pep440.patch(vraw);
|
||||
}
|
||||
}),
|
||||
tag
|
||||
);
|
||||
latest = true;
|
||||
}
|
||||
|
||||
return Meta.setVersion(version, vraw, this.flavor.latest == 'auto' ? latest : this.flavor.latest == 'true');
|
||||
}
|
||||
|
||||
private procMatch(version: Version, tag: tcl.Tag): Version {
|
||||
if (!/^refs\/tags\//.test(this.context.ref) && tag.attrs['value'].length == 0) {
|
||||
return version;
|
||||
}
|
||||
|
||||
let vraw: string;
|
||||
if (tag.attrs['value'].length > 0) {
|
||||
vraw = this.setGlobalExp(tag.attrs['value']);
|
||||
} else {
|
||||
vraw = this.context.ref.replace(/^refs\/tags\//g, '');
|
||||
}
|
||||
|
||||
let tmatch;
|
||||
const isRegEx = tag.attrs['pattern'].match(/^\/(.+)\/(.*)$/);
|
||||
if (isRegEx) {
|
||||
tmatch = vraw.match(new RegExp(isRegEx[1], isRegEx[2]));
|
||||
} else {
|
||||
tmatch = vraw.match(tag.attrs['pattern']);
|
||||
}
|
||||
if (!tmatch) {
|
||||
core.warning(`${tag.attrs['pattern']} does not match ${vraw}.`);
|
||||
return version;
|
||||
}
|
||||
if (typeof tmatch[tag.attrs['group']] === 'undefined') {
|
||||
core.warning(`Group ${tag.attrs['group']} does not exist for ${tag.attrs['pattern']} pattern.`);
|
||||
return version;
|
||||
}
|
||||
|
||||
vraw = this.setValue(tmatch[tag.attrs['group']], tag);
|
||||
return Meta.setVersion(version, vraw, this.flavor.latest == 'auto' ? true : this.flavor.latest == 'true');
|
||||
}
|
||||
|
||||
private procRefBranch(version: Version, tag: tcl.Tag): Version {
|
||||
if (!/^refs\/heads\//.test(this.context.ref)) {
|
||||
return version;
|
||||
}
|
||||
const vraw = this.setValue(this.context.ref.replace(/^refs\/heads\//g, ''), tag);
|
||||
return Meta.setVersion(version, vraw, this.flavor.latest == 'auto' ? false : this.flavor.latest == 'true');
|
||||
}
|
||||
|
||||
private procRefTag(version: Version, tag: tcl.Tag): Version {
|
||||
if (!/^refs\/tags\//.test(this.context.ref)) {
|
||||
return version;
|
||||
}
|
||||
const vraw = this.setValue(this.context.ref.replace(/^refs\/tags\//g, ''), tag);
|
||||
return Meta.setVersion(version, vraw, this.flavor.latest == 'auto' ? true : this.flavor.latest == 'true');
|
||||
}
|
||||
|
||||
private procRefPr(version: Version, tag: tcl.Tag): Version {
|
||||
if (!/^refs\/pull\//.test(this.context.ref)) {
|
||||
return version;
|
||||
}
|
||||
|
||||
const vraw = this.setValue(this.context.ref.replace(/^refs\/pull\//g, '').replace(/\/merge$/g, ''), tag);
|
||||
return Meta.setVersion(version, vraw, this.flavor.latest == 'auto' ? false : this.flavor.latest == 'true');
|
||||
}
|
||||
|
||||
private procEdge(version: Version, tag: tcl.Tag): Version {
|
||||
if (!/^refs\/heads\//.test(this.context.ref)) {
|
||||
return version;
|
||||
}
|
||||
|
||||
const val = this.context.ref.replace(/^refs\/heads\//g, '');
|
||||
if (tag.attrs['branch'].length == 0) {
|
||||
tag.attrs['branch'] = this.repo.default_branch;
|
||||
}
|
||||
if (tag.attrs['branch'] != val) {
|
||||
return version;
|
||||
}
|
||||
|
||||
const vraw = this.setValue('edge', tag);
|
||||
return Meta.setVersion(version, vraw, this.flavor.latest == 'auto' ? false : this.flavor.latest == 'true');
|
||||
}
|
||||
|
||||
private procRaw(version: Version, tag: tcl.Tag): Version {
|
||||
const vraw = this.setValue(this.setGlobalExp(tag.attrs['value']), tag);
|
||||
return Meta.setVersion(version, vraw, this.flavor.latest == 'auto' ? false : this.flavor.latest == 'true');
|
||||
}
|
||||
|
||||
private procSha(version: Version, tag: tcl.Tag): Version {
|
||||
if (!this.context.sha) {
|
||||
return version;
|
||||
}
|
||||
|
||||
let val = this.context.sha;
|
||||
if (tag.attrs['format'] === tcl.ShaFormat.Short) {
|
||||
val = this.context.sha.substring(0, 7);
|
||||
}
|
||||
|
||||
const vraw = this.setValue(val, tag);
|
||||
return Meta.setVersion(version, vraw, this.flavor.latest == 'auto' ? false : this.flavor.latest == 'true');
|
||||
}
|
||||
|
||||
private static setVersion(version: Version, val: string, latest: boolean): Version {
|
||||
if (val.length == 0) {
|
||||
return version;
|
||||
}
|
||||
val = Meta.sanitizeTag(val);
|
||||
if (version.main == undefined) {
|
||||
version.main = val;
|
||||
} else if (val !== version.main) {
|
||||
version.partial.push(val);
|
||||
}
|
||||
if (version.latest == undefined) {
|
||||
version.latest = latest;
|
||||
}
|
||||
return version;
|
||||
}
|
||||
|
||||
public static isRawStatement(pattern: string): boolean {
|
||||
try {
|
||||
const hp = handlebars.parseWithoutProcessing(pattern);
|
||||
if (hp.body.length == 1 && hp.body[0].type == 'MustacheStatement') {
|
||||
return hp.body[0]['path']['parts'].length == 1 && hp.body[0]['path']['parts'][0] == 'raw';
|
||||
}
|
||||
} catch (err) {
|
||||
return false;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
private setValue(val: string, tag: tcl.Tag): string {
|
||||
if (Object.prototype.hasOwnProperty.call(tag.attrs, 'prefix')) {
|
||||
val = `${this.setGlobalExp(tag.attrs['prefix'])}${val}`;
|
||||
} else if (this.flavor.prefix.length > 0) {
|
||||
val = `${this.setGlobalExp(this.flavor.prefix)}${val}`;
|
||||
}
|
||||
if (Object.prototype.hasOwnProperty.call(tag.attrs, 'suffix')) {
|
||||
val = `${val}${this.setGlobalExp(tag.attrs['suffix'])}`;
|
||||
} else if (this.flavor.suffix.length > 0) {
|
||||
val = `${val}${this.setGlobalExp(this.flavor.suffix)}`;
|
||||
}
|
||||
return val;
|
||||
}
|
||||
|
||||
private setGlobalExp(val): string {
|
||||
const context = this.context;
|
||||
const currentDate = this.date;
|
||||
return handlebars.compile(val)({
|
||||
branch: function () {
|
||||
if (!/^refs\/heads\//.test(context.ref)) {
|
||||
return '';
|
||||
}
|
||||
return context.ref.replace(/^refs\/heads\//g, '');
|
||||
},
|
||||
tag: function () {
|
||||
if (!/^refs\/tags\//.test(context.ref)) {
|
||||
return '';
|
||||
}
|
||||
return context.ref.replace(/^refs\/tags\//g, '');
|
||||
},
|
||||
sha: function () {
|
||||
return context.sha.substring(0, 7);
|
||||
},
|
||||
base_ref: function () {
|
||||
if (/^refs\/tags\//.test(context.ref) && context.payload?.base_ref != undefined) {
|
||||
return context.payload.base_ref.replace(/^refs\/heads\//g, '');
|
||||
}
|
||||
// FIXME: keep this for backward compatibility even if doesn't always seem
|
||||
// to return the expected branch. See the comment below.
|
||||
if (/^refs\/pull\//.test(context.ref) && context.payload?.pull_request?.base?.ref != undefined) {
|
||||
return context.payload.pull_request.base.ref;
|
||||
}
|
||||
return '';
|
||||
},
|
||||
is_default_branch: function () {
|
||||
const branch = context.ref.replace(/^refs\/heads\//g, '');
|
||||
// TODO: "base_ref" is available in the push payload but doesn't always seem to
|
||||
// return the expected branch when the push tag event occurs. It's also not
|
||||
// documented in GitHub docs: https://docs.github.com/en/developers/webhooks-and-events/webhooks/webhook-events-and-payloads#push
|
||||
// more context: https://github.com/docker/metadata-action/pull/192#discussion_r854673012
|
||||
// if (/^refs\/tags\//.test(context.ref) && context.payload?.base_ref != undefined) {
|
||||
// branch = context.payload.base_ref.replace(/^refs\/heads\//g, '');
|
||||
// }
|
||||
if (branch == undefined || branch.length == 0) {
|
||||
return 'false';
|
||||
}
|
||||
if (context.payload?.repository?.default_branch == branch) {
|
||||
return 'true';
|
||||
}
|
||||
// following events always trigger for last commit on default branch
|
||||
// https://docs.github.com/en/actions/using-workflows/events-that-trigger-workflows
|
||||
if (/create/.test(context.eventName) || /discussion/.test(context.eventName) || /issues/.test(context.eventName) || /schedule/.test(context.eventName)) {
|
||||
return 'true';
|
||||
}
|
||||
return 'false';
|
||||
},
|
||||
date: function (format, options) {
|
||||
const m = moment(currentDate);
|
||||
let tz = 'UTC';
|
||||
Object.keys(options.hash).forEach(key => {
|
||||
switch (key) {
|
||||
case 'tz':
|
||||
tz = options.hash[key];
|
||||
break;
|
||||
default:
|
||||
throw new Error(`Unknown ${key} attribute`);
|
||||
}
|
||||
});
|
||||
return m.tz(tz).format(format);
|
||||
}
|
||||
});
|
||||
}
|
||||
|
||||
private getImageNames(): Array<string> {
|
||||
const images: Array<string> = [];
|
||||
for (const image of this.images) {
|
||||
if (!image.enable) {
|
||||
continue;
|
||||
}
|
||||
images.push(Meta.sanitizeImageName(image.name));
|
||||
}
|
||||
return images;
|
||||
}
|
||||
|
||||
public getTags(): Array<string> {
|
||||
if (!this.version.main) {
|
||||
return [];
|
||||
}
|
||||
const tags: Array<string> = [];
|
||||
for (const imageName of this.getImageNames()) {
|
||||
tags.push(`${imageName}:${this.version.main}`);
|
||||
for (const partial of this.version.partial) {
|
||||
tags.push(`${imageName}:${partial}`);
|
||||
}
|
||||
if (this.version.latest) {
|
||||
const latestTag = `${this.flavor.prefixLatest ? this.flavor.prefix : ''}latest${this.flavor.suffixLatest ? this.flavor.suffix : ''}`;
|
||||
tags.push(`${imageName}:${Meta.sanitizeTag(latestTag)}`);
|
||||
}
|
||||
}
|
||||
return tags;
|
||||
}
|
||||
|
||||
public getLabels(): Array<string> {
|
||||
const labels: Array<string> = [
|
||||
`org.opencontainers.image.title=${this.repo.name || ''}`,
|
||||
`org.opencontainers.image.description=${this.repo.description || ''}`,
|
||||
`org.opencontainers.image.url=${this.repo.html_url || ''}`,
|
||||
`org.opencontainers.image.source=${this.repo.html_url || ''}`,
|
||||
`org.opencontainers.image.version=${this.version.main || ''}`,
|
||||
`org.opencontainers.image.created=${this.date.toISOString()}`,
|
||||
`org.opencontainers.image.revision=${this.context.sha || ''}`,
|
||||
`org.opencontainers.image.licenses=${this.repo.license?.spdx_id || ''}`
|
||||
];
|
||||
labels.push(...this.inputs.labels);
|
||||
|
||||
return Array.from(
|
||||
new Map<string, string>(
|
||||
labels
|
||||
.map(label => label.split('='))
|
||||
// eslint-disable-next-line @typescript-eslint/no-unused-vars
|
||||
.filter(([_key, ...values]) => values.length > 0)
|
||||
.map(([key, ...values]) => [key, values.join('=')] as [string, string])
|
||||
)
|
||||
)
|
||||
.sort((a, b) => a[0].localeCompare(b[0]))
|
||||
.map(([key, value]) => `${key}=${value}`);
|
||||
}
|
||||
|
||||
public getJSON(): unknown {
|
||||
return {
|
||||
tags: this.getTags(),
|
||||
labels: this.getLabels().reduce((res, label) => {
|
||||
const matches = label.match(/([^=]*)=(.*)/);
|
||||
if (!matches) {
|
||||
return res;
|
||||
}
|
||||
res[matches[1]] = matches[2];
|
||||
return res;
|
||||
}, {})
|
||||
};
|
||||
}
|
||||
|
||||
public getBakeFile(): string {
|
||||
const bakeFile = path.join(ToolkitContext.tmpDir(), 'docker-metadata-action-bake.json');
|
||||
fs.writeFileSync(
|
||||
bakeFile,
|
||||
JSON.stringify(
|
||||
{
|
||||
target: {
|
||||
[this.inputs.bakeTarget]: {
|
||||
tags: this.getTags(),
|
||||
labels: this.getLabels().reduce((res, label) => {
|
||||
const matches = label.match(/([^=]*)=(.*)/);
|
||||
if (!matches) {
|
||||
return res;
|
||||
}
|
||||
res[matches[1]] = matches[2];
|
||||
return res;
|
||||
}, {}),
|
||||
args: {
|
||||
DOCKER_META_IMAGES: this.getImageNames().join(','),
|
||||
DOCKER_META_VERSION: this.version.main
|
||||
}
|
||||
}
|
||||
}
|
||||
},
|
||||
null,
|
||||
2
|
||||
)
|
||||
);
|
||||
|
||||
return bakeFile;
|
||||
}
|
||||
|
||||
private static sanitizeImageName(name: string): string {
|
||||
return name.toLowerCase();
|
||||
}
|
||||
|
||||
private static sanitizeTag(tag: string): string {
|
||||
return tag.replace(/[^a-zA-Z0-9._-]+/g, '-');
|
||||
}
|
||||
}
|
||||
Vendored
+39
@@ -0,0 +1,39 @@
|
||||
interface ExplainedVersion {
|
||||
epoch: number;
|
||||
release: [number, number, number];
|
||||
pre?: [string, number];
|
||||
post?: number;
|
||||
dev?: number;
|
||||
local?: string;
|
||||
public: string;
|
||||
base_version: string;
|
||||
is_prerelease: boolean;
|
||||
is_devrelease: boolean;
|
||||
is_postrelease: boolean;
|
||||
}
|
||||
|
||||
interface Version {
|
||||
epoch: number;
|
||||
release: [number, number, number];
|
||||
pre?: [string, number] | null;
|
||||
post?: [string, number] | null;
|
||||
dev?: [string, number] | null;
|
||||
local?: Array<number> | null;
|
||||
public: string;
|
||||
base_version: string;
|
||||
}
|
||||
|
||||
declare module '@renovate/pep440' {
|
||||
function valid(version: string): string | null;
|
||||
function clean(version: string): string;
|
||||
function explain(version: string): ExplainedVersion;
|
||||
function major(input: string): string;
|
||||
function minor(input: string): string;
|
||||
function patch(input: string): string;
|
||||
function inc(input: string, release: string, preReleaseIdentifier?: string): string;
|
||||
}
|
||||
|
||||
declare module '@renovate/pep440/lib/version' {
|
||||
function stringify(parsed: Version): string;
|
||||
function parse(version: string): Version;
|
||||
}
|
||||
+211
@@ -0,0 +1,211 @@
|
||||
import {parse} from 'csv-parse/sync';
|
||||
import * as core from '@actions/core';
|
||||
|
||||
export enum Type {
|
||||
Schedule = 'schedule',
|
||||
Semver = 'semver',
|
||||
Pep440 = 'pep440',
|
||||
Match = 'match',
|
||||
Edge = 'edge',
|
||||
Ref = 'ref',
|
||||
Raw = 'raw',
|
||||
Sha = 'sha'
|
||||
}
|
||||
|
||||
export enum RefEvent {
|
||||
Branch = 'branch',
|
||||
Tag = 'tag',
|
||||
PR = 'pr'
|
||||
}
|
||||
|
||||
export enum ShaFormat {
|
||||
Short = 'short',
|
||||
Long = 'long'
|
||||
}
|
||||
|
||||
export class Tag {
|
||||
public type?: Type;
|
||||
public attrs: Record<string, string>;
|
||||
|
||||
constructor() {
|
||||
this.attrs = {};
|
||||
}
|
||||
|
||||
public toString(): string {
|
||||
const out: string[] = [`type=${this.type}`];
|
||||
for (const attr in this.attrs) {
|
||||
out.push(`${attr}=${this.attrs[attr]}`);
|
||||
}
|
||||
return out.join(',');
|
||||
}
|
||||
}
|
||||
|
||||
export const DefaultPriorities: Record<Type, string> = {
|
||||
[Type.Schedule]: '1000',
|
||||
[Type.Semver]: '900',
|
||||
[Type.Pep440]: '900',
|
||||
[Type.Match]: '800',
|
||||
[Type.Edge]: '700',
|
||||
[Type.Ref]: '600',
|
||||
[Type.Raw]: '200',
|
||||
[Type.Sha]: '100'
|
||||
};
|
||||
|
||||
export function Transform(inputs: string[]): Tag[] {
|
||||
const tags: Tag[] = [];
|
||||
if (inputs.length == 0) {
|
||||
// prettier-ignore
|
||||
inputs = [
|
||||
`type=schedule`,
|
||||
`type=ref,event=${RefEvent.Branch}`,
|
||||
`type=ref,event=${RefEvent.Tag}`,
|
||||
`type=ref,event=${RefEvent.PR}`
|
||||
];
|
||||
}
|
||||
|
||||
for (const input of inputs) {
|
||||
tags.push(Parse(input));
|
||||
}
|
||||
const sorted = tags.sort((tag1, tag2) => {
|
||||
if (Number(tag1.attrs['priority']) < Number(tag2.attrs['priority'])) {
|
||||
return 1;
|
||||
}
|
||||
if (Number(tag1.attrs['priority']) > Number(tag2.attrs['priority'])) {
|
||||
return -1;
|
||||
}
|
||||
return 0;
|
||||
});
|
||||
|
||||
core.startGroup(`Processing tags input`);
|
||||
for (const tag of sorted) {
|
||||
core.info(tag.toString());
|
||||
}
|
||||
core.endGroup();
|
||||
|
||||
return sorted;
|
||||
}
|
||||
|
||||
export function Parse(s: string): Tag {
|
||||
const fields = parse(s, {
|
||||
relaxColumnCount: true,
|
||||
skipEmptyLines: true
|
||||
})[0];
|
||||
|
||||
const tag = new Tag();
|
||||
for (const field of fields) {
|
||||
const parts = field
|
||||
.toString()
|
||||
.split(/(?<=^[^=]+?)=/)
|
||||
.map(item => item.trim());
|
||||
if (parts.length == 1) {
|
||||
tag.attrs['value'] = parts[0];
|
||||
} else {
|
||||
const key = parts[0].toLowerCase();
|
||||
const value = parts[1];
|
||||
switch (key) {
|
||||
case 'type': {
|
||||
if (!Object.values(Type).includes(value)) {
|
||||
throw new Error(`Unknown tag type attribute: ${value}`);
|
||||
}
|
||||
tag.type = value;
|
||||
break;
|
||||
}
|
||||
default: {
|
||||
tag.attrs[key] = value;
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if (tag.type == undefined) {
|
||||
tag.type = Type.Raw;
|
||||
}
|
||||
|
||||
switch (tag.type) {
|
||||
case Type.Schedule: {
|
||||
if (!Object.prototype.hasOwnProperty.call(tag.attrs, 'pattern')) {
|
||||
tag.attrs['pattern'] = 'nightly';
|
||||
}
|
||||
break;
|
||||
}
|
||||
case Type.Semver:
|
||||
case Type.Pep440: {
|
||||
if (!Object.prototype.hasOwnProperty.call(tag.attrs, 'pattern')) {
|
||||
throw new Error(`Missing pattern attribute for ${s}`);
|
||||
}
|
||||
if (!Object.prototype.hasOwnProperty.call(tag.attrs, 'value')) {
|
||||
tag.attrs['value'] = '';
|
||||
}
|
||||
break;
|
||||
}
|
||||
case Type.Match: {
|
||||
if (!Object.prototype.hasOwnProperty.call(tag.attrs, 'pattern')) {
|
||||
throw new Error(`Missing pattern attribute for ${s}`);
|
||||
}
|
||||
if (!Object.prototype.hasOwnProperty.call(tag.attrs, 'group')) {
|
||||
tag.attrs['group'] = '0';
|
||||
}
|
||||
if (isNaN(+tag.attrs['group'])) {
|
||||
throw new Error(`Invalid match group for ${s}`);
|
||||
}
|
||||
if (!Object.prototype.hasOwnProperty.call(tag.attrs, 'value')) {
|
||||
tag.attrs['value'] = '';
|
||||
}
|
||||
break;
|
||||
}
|
||||
case Type.Edge: {
|
||||
if (!Object.prototype.hasOwnProperty.call(tag.attrs, 'branch')) {
|
||||
tag.attrs['branch'] = '';
|
||||
}
|
||||
break;
|
||||
}
|
||||
case Type.Ref: {
|
||||
if (!Object.prototype.hasOwnProperty.call(tag.attrs, 'event')) {
|
||||
throw new Error(`Missing event attribute for ${s}`);
|
||||
}
|
||||
if (
|
||||
!Object.keys(RefEvent)
|
||||
.map(k => RefEvent[k])
|
||||
.includes(tag.attrs['event'])
|
||||
) {
|
||||
throw new Error(`Invalid event for ${s}`);
|
||||
}
|
||||
if (tag.attrs['event'] == RefEvent.PR && !Object.prototype.hasOwnProperty.call(tag.attrs, 'prefix')) {
|
||||
tag.attrs['prefix'] = 'pr-';
|
||||
}
|
||||
break;
|
||||
}
|
||||
case Type.Raw: {
|
||||
if (!Object.prototype.hasOwnProperty.call(tag.attrs, 'value')) {
|
||||
throw new Error(`Missing value attribute for ${s}`);
|
||||
}
|
||||
break;
|
||||
}
|
||||
case Type.Sha: {
|
||||
if (!Object.prototype.hasOwnProperty.call(tag.attrs, 'prefix')) {
|
||||
tag.attrs['prefix'] = 'sha-';
|
||||
}
|
||||
if (!Object.prototype.hasOwnProperty.call(tag.attrs, 'format')) {
|
||||
tag.attrs['format'] = ShaFormat.Short;
|
||||
}
|
||||
if (
|
||||
!Object.keys(ShaFormat)
|
||||
.map(k => ShaFormat[k])
|
||||
.includes(tag.attrs['format'])
|
||||
) {
|
||||
throw new Error(`Invalid format for ${s}`);
|
||||
}
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
if (!Object.prototype.hasOwnProperty.call(tag.attrs, 'enable')) {
|
||||
tag.attrs['enable'] = 'true';
|
||||
}
|
||||
if (!Object.prototype.hasOwnProperty.call(tag.attrs, 'priority')) {
|
||||
tag.attrs['priority'] = DefaultPriorities[tag.type];
|
||||
}
|
||||
|
||||
return tag;
|
||||
}
|
||||
Reference in New Issue
Block a user