4564375014

Build Type

push

github

Committed by Markus Felten

Commit Message

fix: docker entrypoints

Run Details

324 of 387 branches covered (83.72%)

Branch coverage included in aggregate %.

3 of 5 new or added lines in 1 file covered. (60.0%)

23 existing lines in 2 files now uncovered.

2447 of 2619 relevant lines covered (93.43%)

9.79 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

95.6

/src/output/docker.mjs

import { join } from "node:path";
import { readFile } from "node:fs/promises";
import { execa } from "execa";
import { EmptyContentEntry, ReadableStreamContentEntry } from "content-entry";
import { transform } from "content-entry-transform";
import { aggregateFifo } from "aggregate-async-iterator";
import {
  keyValueTransformer,
  equalSeparatedKeyValuePairOptions
} from "key-value-transformer";
import { Packager } from "./packager.mjs";
import {
  fieldProvider,
  copyEntries,
  utf8StreamOptions,
  quote
} from "../util.mjs";

const DOCKERFILE = "Dockerfile";

function* keyValueLines(key, value, options) {
  yield `LABEL ${quote(key, '"')}=${quote(value, '"')}${options.lineEnding}`;
}

const labelKeyValuePairs = {
  ...equalSeparatedKeyValuePairOptions,
  keyValueLines
};

const dependenciesToFrom = {
  node: "node",
  "nginx-mainline": "nginx",
  nginx: "nginx"
};

export class DOCKER extends Packager {
  static get name() {
    return "docker";
  }

  static get description() {
    return `generate container image with ${this.name}`;
  }

  async execute(
    sources,
    transformer,
    dependencies,
    options,
    expander = v => v
  ) {
    const { properties, staging } = await this.prepareExecute(options);

    async function* headLines() {
      for (const [k, v] of Object.entries({
        ...properties.from,
        ...Object.fromEntries(
          Object.entries(dependencies)
            .filter(([k, v]) => dependenciesToFrom[k])
            .map(([k, v]) => [dependenciesToFrom[k], v.replace(/[>=]*/, "")])
        )
      })) {
        yield `FROM ${k}:${v}\n`;
      }
    }

    async function* trailingLines() {
      yield "WORKDIR /app\n";
      yield "COPY . .\n";
      if (properties.entrypoints) {
        yield `ENTRYPOINT ["node", ${Object.values(properties.entrypoints)[0]}]\n`;
        yield `CMD [ "node", ${Object.values(properties.entrypoints)[0]} ]\n`;
      }
    }

    const fp = fieldProvider(properties, fields);

    transformer.push({
      name: DOCKERFILE,
      match: entry => entry.name === DOCKERFILE,
      transform: async entry =>
        new ReadableStreamContentEntry(
          entry.name,
          keyValueTransformer(await entry.readStream, fp, {
            ...labelKeyValuePairs,
            headLines,
            trailingLines
          })
        ),
      createEntryWhenMissing: () => new EmptyContentEntry(DOCKERFILE)
    });

    for await (const file of copyEntries(
      transform(aggregateFifo(sources), transformer),
      staging,
      expander
    )) {
      if (options.verbose) {
        console.log(file.destination);
      }
    }

    if (options.verbose) {
      console.log(await readFile(join(staging, DOCKERFILE), utf8StreamOptions));
    }

    let tag = `${properties.name}:${properties.version}`;
    let image = "";

    if (!options.dry) {
      const docker = await execa(
        this.constructor.name,
        ["build", "--tag", tag, staging],
        {
          cwd: staging
        }
      );

      const lines = docker.stderr.split(/\n/);
      const wl = lines.filter(l => l.match(/writing\s+image/));
      if (wl?.[0]) {
        image = wl[0].split(/\s+/)[3];
      }

      if (options.verbose) {
        console.log(docker.stderr);
        console.log(docker.stdout);
      }
    }

    return image;
  }
}

/**
 * @see {https://docs.docker.com/engine/reference/builder/}
 */
const fields = {
  version: { type: "string", mandatory: true },
  description: { type: "string" },
  author: { alias: "maintainer", type: "string" }
};

1	import { join } from "node:path";	14✔
2	import { readFile } from "node:fs/promises";	14✔
3	import { execa } from "execa";	14✔
4	import { EmptyContentEntry, ReadableStreamContentEntry } from "content-entry";	14✔
5	import { transform } from "content-entry-transform";	14✔
6	import { aggregateFifo } from "aggregate-async-iterator";	14✔
7	import {	14✔
8	keyValueTransformer,	14✔
9	equalSeparatedKeyValuePairOptions	14✔
10	} from "key-value-transformer";	14✔
11	import { Packager } from "./packager.mjs";	14✔
12	import {	14✔
13	fieldProvider,	14✔
14	copyEntries,	14✔
15	utf8StreamOptions,	14✔
16	quote	14✔
17	} from "../util.mjs";	14✔
18		14✔
19	const DOCKERFILE = "Dockerfile";	14✔
20		14✔
21	function* keyValueLines(key, value, options) {	2✔
22	yield `LABEL ${quote(key, '"')}=${quote(value, '"')}${options.lineEnding}`;	2✔
23	}	2✔
24		14✔
25	const labelKeyValuePairs = {	14✔
26	...equalSeparatedKeyValuePairOptions,	14✔
27	keyValueLines	14✔
28	};	14✔
29		14✔
30	const dependenciesToFrom = {	14✔
31	node: "node",	14✔
32	"nginx-mainline": "nginx",	14✔
33	nginx: "nginx"	14✔
34	};	14✔
35		14✔
36	export class DOCKER extends Packager {	14✔
37	static get name() {	14✔
38	return "docker";	7✔
39	}	7✔
40		14✔
41	static get description() {	14✔
42	return `generate container image with ${this.name}`;	2✔
43	}	2✔
44		14✔
45	async execute(	14✔
46	sources,	1✔
47	transformer,	1✔
48	dependencies,	1✔
49	options,	1✔
50	expander = v => v	1✔
51	) {	1✔
52	const { properties, staging } = await this.prepareExecute(options);	1✔
53		1✔
54	async function* headLines() {	1✔
55	for (const [k, v] of Object.entries({	1✔
56	...properties.from,	1✔
57	...Object.fromEntries(	1✔
58	Object.entries(dependencies)	1✔
59	.filter(([k, v]) => dependenciesToFrom[k])	1✔
60	.map(([k, v]) => [dependenciesToFrom[k], v.replace(/[>=]*/, "")])	1✔
61	)	1✔
62	})) {	1✔
63	yield `FROM ${k}:${v}\n`;	1✔
64	}	1✔
65	}	1✔
66		1✔
67	async function* trailingLines() {	1✔
68	yield "WORKDIR /app\n";	1✔
69	yield "COPY . .\n";	1✔
70	if (properties.entrypoints) {	1!
NEW 71	yield `ENTRYPOINT ["node", ${Object.values(properties.entrypoints)[0]}]\n`;	×
NEW 72	yield `CMD [ "node", ${Object.values(properties.entrypoints)[0]} ]\n`;	×
UNCOV 73	}	×
74	}	1✔
75		1✔
76	const fp = fieldProvider(properties, fields);	1✔
77		1✔
78	transformer.push({	1✔
79	name: DOCKERFILE,	1✔
80	match: entry => entry.name === DOCKERFILE,	1✔
81	transform: async entry =>	1✔
82	new ReadableStreamContentEntry(	1✔
83	entry.name,	1✔
84	keyValueTransformer(await entry.readStream, fp, {	1✔
85	...labelKeyValuePairs,	1✔
86	headLines,	1✔
87	trailingLines	1✔
88	})	1✔
89	),	1✔
90	createEntryWhenMissing: () => new EmptyContentEntry(DOCKERFILE)	1✔
91	});	1✔
92		1✔
93	for await (const file of copyEntries(	1✔
94	transform(aggregateFifo(sources), transformer),	1✔
95	staging,	1✔
96	expander	1✔
97	)) {	1✔
98	if (options.verbose) {	3✔
99	console.log(file.destination);	3✔
100	}	3✔
101	}	3✔
102		1✔
103	if (options.verbose) {	1✔
104	console.log(await readFile(join(staging, DOCKERFILE), utf8StreamOptions));	1✔
105	}	1✔
106		1✔
107	let tag = `${properties.name}:${properties.version}`;	1✔
108	let image = "";	1✔
109		1✔
110	if (!options.dry) {	1✔
111	const docker = await execa(	1✔
112	this.constructor.name,	1✔
113	["build", "--tag", tag, staging],	1✔
114	{	1✔
115	cwd: staging	1✔
116	}	1✔
117	);	1✔
118		1✔
119	const lines = docker.stderr.split(/\n/);	1✔
120	const wl = lines.filter(l => l.match(/writing\s+image/));	1✔
121	if (wl?.[0]) {	1!
122	image = wl[0].split(/\s+/)[3];	×
123	}	×
124		1✔
125	if (options.verbose) {	1✔
126	console.log(docker.stderr);	1✔
127	console.log(docker.stdout);	1✔
128	}	1✔
129	}	1✔
130		1✔
131	return image;	1✔
132	}	1✔
133	}	14✔
134		14✔
135	/**	14✔
136	* @see {https://docs.docker.com/engine/reference/builder/}	14✔
137	*/	14✔
138	const fields = {	14✔
139	version: { type: "string", mandatory: true },	14✔
140	description: { type: "string" },	14✔
141	author: { alias: "maintainer", type: "string" }	14✔
142	};	14✔

arlac77 / npm-pkgbuild / 4564375014

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous