@fontoxml/fontoxml-development-tools 3.10.0 → 3.12.0-beta.1

package/src/modules/shared/src/controller-templates/command.backend.build.controller.factory.js

@@ -0,0 +1,273 @@
+import fs from 'fs-extra';
+import path from 'path';
+
+import ensureDockerCommands from '../ensureDockerCommands.js';
+import executeAndLog, {
+	getVerbosityLevel,
+	VERBOSITY_LEVEL,
+} from '../executeAndLog.js';
+import setFileVisibility from '../setFileVisibility.js';
+import BackendManifest from './docker/BackendManifest.js';
+import copyWhitelistedFiles from './docker/copyWhitelistedFiles.js';
+import dockerCleanup from './docker/dockerCleanup.js';
+import tryDockerLogout from './docker/tryDockerLogout.js';
+import validateBackendInstance from './docker/validateBackendInstance.js';
+
+/** @typedef {import('../addBackendDockerCommands').AddBackendDockerCommandsOptions} AddBackendDockerCommandsOptions */
+
+/**
+ * @param {AddBackendDockerCommandsOptions} options
+ *
+ * @returns {(req: AskNicelyRequest, res: FdtResponse) => Promise<void>}
+ */
+export default function backendBuildCommandFactory(options) {
+	return async function backendBuildCommand(req, res) {
+		res.caption(req.command.getLongName());
+
+		const directoryPath = path.resolve(
+			req.options.location ? req.options.location : process.cwd()
+		);
+		const temporaryDirectoryPath = path.join(
+			directoryPath,
+			options.temporaryBuildDirectoryName
+		);
+		const imageName = req.options['image-name']
+			? req.options['image-name']
+			: options.defaultImageName;
+		const imageTag = req.options['image-tag']
+			? req.options['image-tag']
+			: options.defaultImageTag;
+		const manifestFilePath = path.join(
+			directoryPath,
+			options.manifestFileName
+		);
+		const verbosityLevel = getVerbosityLevel(
+			req.options.verbose,
+			req.options.debug
+		);
+
+		// Check if the working directory path exists and is a directory.
+		try {
+			const stats = await fs.stat(directoryPath);
+			if (!stats.isDirectory()) {
+				throw new res.InputError(
+					'The provided location is not a directory.'
+				);
+			}
+		} catch (error) {
+			if (error.code === 'ENOENT') {
+				throw new res.InputError(
+					'The provided location does not exist.'
+				);
+			}
+			throw error;
+		}
+
+		// Ensure that the Docker commands are available.
+		await ensureDockerCommands(directoryPath, res, {
+			checkDocker: true,
+			checkDockerCompose: false,
+		});
+
+		let pidToKillOnForceExit = null;
+		const setPidToKillOnForceExit = (process) => {
+			pidToKillOnForceExit = process && process.pid;
+		};
+
+		// Ensure we cleanup before exiting on SIGINT.
+		let stopping = false;
+		process.on('SIGINT', (_code) => {
+			if (stopping) {
+				if (pidToKillOnForceExit) {
+					process.kill(pidToKillOnForceExit);
+				}
+				process.exit();
+				return;
+			}
+
+			stopping = true;
+			res.log('Gracefully stopping... (press Ctrl+C again to force)');
+			// eslint-disable-next-line consistent-return
+			return dockerCleanup(
+				temporaryDirectoryPath,
+				undefined,
+				res,
+				verbosityLevel
+			).then(() => {
+				process.exit();
+			});
+		});
+
+		try {
+			await validateBackendInstance(directoryPath, options);
+
+			// Cleanup possible remaining resources from a previous build or run.
+			await dockerCleanup(
+				temporaryDirectoryPath,
+				undefined,
+				res,
+				verbosityLevel
+			);
+
+			const destroySpinner = res.spinner(
+				`Building the production image "${imageName}:${imageTag}" at "${directoryPath}"...`
+			);
+
+			// Read the manifest file.
+			const manifestObj = await BackendManifest.fromJsonFile(
+				manifestFilePath,
+				options.manifestVersionPropertyName
+			);
+
+			// Retrieve data for the docker image
+			let dockerData;
+			try {
+				const requestObj = {
+					[options.licenseProductName]: {
+						docker: {
+							version: manifestObj.version,
+						},
+					},
+				};
+				const productData = await req.fdt.license.getDataForProducts(
+					requestObj
+				);
+				dockerData =
+					productData.products[options.licenseProductName].docker;
+			} catch (error) {
+				if (error.statusCode === 404) {
+					error.solution = `This error might be caused by requesting a nonexistent ${options.productLabel} version, please check your version.`;
+				}
+				throw error;
+			}
+
+			// Create a hidden temporary directory.
+			await fs.mkdir(temporaryDirectoryPath);
+			await setFileVisibility(temporaryDirectoryPath, false);
+			// Copy the instance files into the temporary directory.
+			const dockerfileContent = await fs.readFile(
+				options.instanceBuildDockerfilePath,
+				'utf8'
+			);
+			// Rewrite the image in the Dockerfile.
+			const fixedDockerfileContent = dockerfileContent.replace(
+				'${image}',
+				dockerData.image
+			);
+			await fs.writeFile(
+				path.join(temporaryDirectoryPath, 'Dockerfile'),
+				fixedDockerfileContent,
+				'utf8'
+			);
+			const temporaryInstanceDirectoryPath = path.join(
+				temporaryDirectoryPath,
+				'instance'
+			);
+			await fs.ensureDir(temporaryInstanceDirectoryPath);
+			// Copy whitelisted files.
+			await copyWhitelistedFiles(
+				options.whitelist,
+				directoryPath,
+				temporaryInstanceDirectoryPath
+			);
+
+			// Pull the docker image.
+			try {
+				await executeAndLog(
+					res,
+					'docker',
+					[
+						'login',
+						dockerData.registry,
+						'-u',
+						dockerData.login,
+						'-p',
+						dockerData.password,
+					],
+					null,
+					VERBOSITY_LEVEL.NORMAL,
+					false,
+					setPidToKillOnForceExit
+				);
+				await executeAndLog(
+					res,
+					'docker',
+					['pull', dockerData.image],
+					null,
+					verbosityLevel,
+					false,
+					setPidToKillOnForceExit
+				);
+			} catch (error) {
+				await tryDockerLogout(
+					dockerData.registry,
+					res,
+					setPidToKillOnForceExit
+				);
+				throw new res.ErrorWithInnerError(
+					'Failed to retrieve the image file.',
+					error
+				);
+			}
+
+			// Build the docker image.
+			try {
+				await executeAndLog(
+					res,
+					'docker',
+					['build', '-t', `${imageName}:${imageTag}`, '.'],
+					temporaryDirectoryPath,
+					verbosityLevel,
+					false,
+					setPidToKillOnForceExit
+				);
+			} finally {
+				await tryDockerLogout(
+					dockerData.registry,
+					res,
+					setPidToKillOnForceExit
+				);
+			}
+
+			// Send telemetry.
+			await req.fdt.license.sendTelemetry({
+				product: req.command.parent.name,
+				type: 'docker',
+				version: manifestObj.version,
+				action: req.command.name,
+			});
+
+			destroySpinner();
+
+			// Cleanup temporary directory.
+			await dockerCleanup(
+				temporaryDirectoryPath,
+				undefined,
+				res,
+				verbosityLevel
+			);
+		} catch (error) {
+			if (!stopping) {
+				res.notice(
+					options.documentationExecuteError
+						? `See our documentation at ${options.documentationExecuteError} for help.`
+						: 'See our documentation for help.'
+				);
+			}
+
+			try {
+				await dockerCleanup(
+					temporaryDirectoryPath,
+					undefined,
+					res,
+					verbosityLevel
+				);
+			} catch (_cleanupError) {
+				// Ignore cleanup error.
+			}
+
+			// Re-throw the actual error.
+			throw error;
+		}
+	};
+}

package/src/modules/shared/src/controller-templates/command.backend.download-self-contained.controller.factory.js

@@ -0,0 +1,131 @@
+import fs from 'fs-extra';
+import fetch from 'node-fetch';
+import path from 'path';
+import url from 'url';
+
+/** @typedef {import('../addBackendDownloadSelfContainedCommands').AddBackendDownloadSelfContainedCommandsOptions} AddBackendDownloadSelfContainedCommandsOptions */
+
+/**
+ * @param {AddBackendDownloadSelfContainedCommandsOptions} options
+ *
+ * @returns {(req: AskNicelyRequest, res: FdtResponse) => Promise<void>}
+ */
+export default function backendDownloadSelfContainedCommandFactory(options) {
+	return async function backendDownloadSelfContainedCommand(req, res) {
+		res.caption(req.command.getLongName());
+
+		const directoryPath = path.resolve(
+			req.options.location ? req.options.location : process.cwd()
+		);
+		const version = req.options.version;
+		const runtime = req.options.runtime;
+
+		const destroySpinner = res.spinner(
+			`Downloading self-contained build...`
+		);
+
+		// Get the download URI for the self-contained build.
+		let downloadUri;
+		try {
+			const requestObj = {
+				[options.licenseProductName]: {
+					selfContained: {
+						runtime,
+						version,
+					},
+				},
+			};
+			const productData = await req.fdt.license.getDataForProducts(
+				requestObj
+			);
+			downloadUri =
+				productData.products[options.licenseProductName].selfContained
+					.uri;
+		} catch (error) {
+			if (error.statusCode === 404) {
+				try {
+					const sdkVersions =
+						await req.fdt.license.getVersionsForProduct(
+							options.licenseProductName
+						);
+					// eslint-disable-next-line no-ex-assign
+					error = new res.ErrorWithSolution(
+						`Could not download self-contained for version (${version}) and runtime environment (${runtime}). Please check if it is a valid version and runtime environment.`,
+						`The latest version is ${sdkVersions.getLatestStable()}, run \`fdt ${
+							options.commandPrefix
+						} versions\` to get a list of all available versions and run \`fdt ${
+							options.commandPrefix
+						} download-self-contained --help\` to get a list of all available runtime environments.`,
+						error
+					);
+				} catch (_error) {
+					throw new res.ErrorWithSolution(
+						`Could not download self-contained for version (${version}) and runtime environment (${runtime}). Please check if it is a valid version and runtime environment.`,
+						`Run \`fdt ${options.commandPrefix} versions\` to get a list of all available versions and run \`fdt ${options.commandPrefix} download-self-contained --help\` to get a list of all available runtime environments.`,
+						error
+					);
+				}
+			}
+			throw error;
+		}
+
+		// Download the self-contained build.
+		const data = await fetch(downloadUri, { method: 'GET' }).then(
+			async (response) => {
+				switch (response.status) {
+					case 200:
+						try {
+							return Buffer.from(await response.arrayBuffer());
+						} catch (_err) {
+							throw new Error(
+								`Invalid response data from the self-contained builds server.`
+							);
+						}
+					case 401:
+					case 403:
+						throw new Error(
+							'You are currently not allowed to download this self-contained build, even though you might have the license for it.'
+						);
+					case 404:
+						throw new Error(
+							'The file for the requested self-contained build could not be found.'
+						);
+					default:
+						throw new Error(
+							`Invalid response from the self-contained builds server (${response.status}).`
+						);
+				}
+			}
+		);
+
+		// Write the self-contained build to disk.
+		const parsed = url.parse(downloadUri);
+		const filename = path.basename(parsed.pathname);
+		const filePath = path.join(directoryPath, filename);
+		try {
+			await fs.outputFile(filePath, data);
+		} catch (error) {
+			throw new res.ErrorWithInnerError(
+				'Could not save self-contained build download to disk.',
+				error
+			);
+		}
+
+		await req.fdt.license.sendTelemetry({
+			product: req.command.parent.name,
+			type: 'selfContained',
+			runtime: req.options.runtime,
+			version,
+			action: req.command.name,
+		});
+
+		destroySpinner();
+		res.break();
+		const locationString = req.options.location
+			? path.isAbsolute(req.options.location)
+				? filePath
+				: path.join(req.options.location, filename)
+			: filename;
+		res.notice(`Saved self-contained build to ${locationString}`);
+	};
+}

package/src/modules/shared/src/controller-templates/command.backend.init.controller.factory.js

@@ -0,0 +1,88 @@
+import fs from 'fs-extra';
+import path from 'path';
+
+import setFileVisibility from '../setFileVisibility.js';
+import BackendManifest from './docker/BackendManifest.js';
+
+/** @typedef {import('../addBackendDockerCommands').AddBackendDockerCommandsOptions} AddBackendDockerCommandsOptions */
+
+/**
+ * @param {AddBackendDockerCommandsOptions} options
+ *
+ * @returns {(req: AskNicelyRequest, res: FdtResponse) => Promise<void>}
+ */
+export default function backendInitCommandFactory(options) {
+	return async function backendInitCommand(req, res) {
+		res.caption(req.command.getLongName());
+
+		// Check if the version exists.
+		const sdkVersions = await req.fdt.license.getVersionsForProduct(
+			options.licenseProductName
+		);
+		const version = req.options.version;
+		if (!sdkVersions.includes(version)) {
+			throw new res.ErrorWithSolution(
+				`Could not initialize for version (${version}), please check if it is a valid version. The latest version is ${sdkVersions.getLatestStable()}.`,
+				`Run \`fdt ${options.commandPrefix} versions\` to get a list of all available versions.`
+			);
+		}
+
+		const directoryPath = path.resolve(
+			req.options.location ? req.options.location : process.cwd()
+		);
+		// Ensure the directory exist.
+		await fs.ensureDir(directoryPath);
+		// Ensure the directory is empty if it does exist.
+		const files = await fs.readdir(directoryPath);
+		if (files.length) {
+			throw new res.InputError(
+				`The directory "${directoryPath}" is not empty.`
+			);
+		}
+
+		const destroySpinner = res.spinner(
+			`Initializing a ${options.productLabel} instance at "${directoryPath}"...`
+		);
+		try {
+			await fs.copy(
+				options.instanceTemplateDirectoryPath,
+				directoryPath,
+				{
+					filter: (src, _dest) => {
+						const filename = path.basename(src);
+						return filename !== '.gitkeep';
+					},
+				}
+			);
+			const data = new BackendManifest(
+				options.manifestVersionPropertyName,
+				version
+			);
+			const manifest = path.join(directoryPath, options.manifestFileName);
+			await fs.writeJson(manifest, data);
+			await setFileVisibility(manifest, false);
+		} catch (error) {
+			await fs.emptyDir(directoryPath);
+			destroySpinner();
+			throw error;
+		}
+
+		await req.fdt.license.sendTelemetry({
+			product: req.command.parent.name,
+			type: 'docker',
+			version,
+			action: req.command.name,
+		});
+
+		destroySpinner();
+
+		res.log(
+			'Complete the configuration before building or running the instance.'
+		);
+		if (options.documentationGettingStartedGuide) {
+			res.log(
+				`See ${options.documentationGettingStartedGuide} for more information.`
+			);
+		}
+	};
+}