builder/lib/builder/builder.js

  1. const {promisify} = require("util");
  2. const rimraf = promisify(require("rimraf"));
  3. const log = require("@ui5/logger").getGroupLogger("builder:builder");
  4. const resourceFactory = require("@ui5/fs").resourceFactory;
  5. const MemAdapter = require("@ui5/fs").adapters.Memory;
  6. const typeRepository = require("../types/typeRepository");
  7. const taskRepository = require("../tasks/taskRepository");
  8. const BuildContext = require("./BuildContext");
  11. // Set of tasks for development
  12. const devTasks = [
  13. 	"replaceCopyright",
  14. 	"replaceVersion",
  15. 	"replaceBuildtime",
  16. 	"buildThemes"
  17. ];
  19. /**
  20.  * Calculates the elapsed build time and returns a prettified output
  21.  *
  22.  * @private
  23.  * @param {Array} startTime Array provided by <code>process.hrtime()</code>
  24.  * @returns {string} Difference between now and the provided time array as formatted string
  25.  */
  26. function getElapsedTime(startTime) {
  27. 	const prettyHrtime = require("pretty-hrtime");
  28. 	const timeDiff = process.hrtime(startTime);
  29. 	return prettyHrtime(timeDiff);
  30. }
  32. /**
  33.  * Creates the list of tasks to be executed by the build process
  34.  *
  35.  * Sets specific tasks to be disabled by default, these tasks need to be included explicitly.
  36.  * Based on the selected build mode (dev|selfContained|preload), different tasks are enabled.
  37.  * Tasks can be enabled or disabled. The wildcard <code>*</code> is also supported and affects all tasks.
  38.  *
  39.  * @private
  40.  * @param {object} parameters
  41.  * @param {boolean} parameters.dev Sets development mode, which only runs essential tasks
  42.  * @param {boolean} parameters.selfContained
  43.  *			True if a the build should be self-contained or false for prelead build bundles
  44.  * @param {boolean} parameters.jsdoc True if a JSDoc build should be executed
  45.  * @param {Array} parameters.includedTasks Task list to be included from build
  46.  * @param {Array} parameters.excludedTasks Task list to be excluded from build
  47.  * @returns {Array} Return a task list for the builder
  48.  */
  49. function composeTaskList({dev, selfContained, jsdoc, includedTasks, excludedTasks}) {
  50. 	const definedTasks = taskRepository.getAllTaskNames();
  51. 	let selectedTasks = definedTasks.reduce((list, key) => {
  52. 		list[key] = true;
  53. 		return list;
  54. 	}, {});
  56. 	// Exclude non default tasks
  57. 	selectedTasks.generateManifestBundle = false;
  58. 	selectedTasks.generateStandaloneAppBundle = false;
  59. 	selectedTasks.transformBootstrapHtml = false;
  60. 	selectedTasks.generateJsdoc = false;
  61. 	selectedTasks.executeJsdocSdkTransformation = false;
  62. 	selectedTasks.generateCachebusterInfo = false;
  63. 	selectedTasks.generateApiIndex = false;
  64. 	selectedTasks.generateThemeDesignerResources = false;
  66. 	// Disable generateResourcesJson due to performance.
  67. 	// When executed it analyzes each module's AST and therefore
  68. 	// takes up much time (~10% more)
  69. 	selectedTasks.generateResourcesJson = false;
  71. 	if (selfContained) {
  72. 		// No preloads, bundle only
  73. 		selectedTasks.generateComponentPreload = false;
  74. 		selectedTasks.generateStandaloneAppBundle = true;
  75. 		selectedTasks.transformBootstrapHtml = true;
  76. 		selectedTasks.generateLibraryPreload = false;
  77. 	}
  79. 	// TODO 3.0: exclude generateVersionInfo if not --all is used
  81. 	if (jsdoc) {
  82. 		// Include JSDoc tasks
  83. 		selectedTasks.generateJsdoc = true;
  84. 		selectedTasks.executeJsdocSdkTransformation = true;
  85. 		selectedTasks.generateApiIndex = true;
  87. 		// Include theme build as required for SDK
  88. 		selectedTasks.buildThemes = true;
  90. 		// Exclude all tasks not relevant to JSDoc generation
  91. 		selectedTasks.replaceCopyright = false;
  92. 		selectedTasks.replaceVersion = false;
  93. 		selectedTasks.replaceBuildtime = false;
  94. 		selectedTasks.generateComponentPreload = false;
  95. 		selectedTasks.generateLibraryPreload = false;
  96. 		selectedTasks.generateLibraryManifest = false;
  97. 		selectedTasks.createDebugFiles = false;
  98. 		selectedTasks.uglify = false;
  99. 		selectedTasks.generateFlexChangesBundle = false;
  100. 		selectedTasks.generateManifestBundle = false;
  101. 	}
  103. 	// Only run essential tasks in development mode, it is not desired to run time consuming tasks during development.
  104. 	if (dev) {
  105. 		// Overwrite all other tasks with noop promise
  106. 		Object.keys(selectedTasks).forEach((key) => {
  107. 			if (devTasks.indexOf(key) === -1) {
  108. 				selectedTasks[key] = false;
  109. 			}
  110. 		});
  111. 	}
  113. 	// Exclude tasks
  114. 	for (let i = 0; i < excludedTasks.length; i++) {
  115. 		const taskName = excludedTasks[i];
  116. 		if (taskName === "*") {
  117. 			Object.keys(selectedTasks).forEach((sKey) => {
  118. 				selectedTasks[sKey] = false;
  119. 			});
  120. 			break;
  121. 		}
  122. 		if (selectedTasks[taskName] === true) {
  123. 			selectedTasks[taskName] = false;
  124. 		} else if (typeof selectedTasks[taskName] === "undefined") {
  125. 			log.warn(`Unable to exclude task '${taskName}': Task is unknown`);
  126. 		}
  127. 	}
  129. 	// Include tasks
  130. 	for (let i = 0; i < includedTasks.length; i++) {
  131. 		const taskName = includedTasks[i];
  132. 		if (taskName === "*") {
  133. 			Object.keys(selectedTasks).forEach((sKey) => {
  134. 				selectedTasks[sKey] = true;
  135. 			});
  136. 			break;
  137. 		}
  138. 		if (selectedTasks[taskName] === false) {
  139. 			selectedTasks[taskName] = true;
  140. 		} else if (typeof selectedTasks[taskName] === "undefined") {
  141. 			log.warn(`Unable to include task '${taskName}': Task is unknown`);
  142. 		}
  143. 	}
  145. 	// Filter only for tasks that will be executed
  146. 	selectedTasks = Object.keys(selectedTasks).filter((task) => selectedTasks[task]);
  148. 	return selectedTasks;
  149. }
  151. async function executeCleanupTasks(buildContext) {
  152. 	log.info("Executing cleanup tasks...");
  153. 	await buildContext.executeCleanupTasks();
  154. }
  156. function registerCleanupSigHooks(buildContext) {
  157. 	function createListener(exitCode) {
  158. 		return function() {
  159. 			// Asynchronously cleanup resources, then exit
  160. 			executeCleanupTasks(buildContext).then(() => {
  161. 				process.exit(exitCode);
  162. 			});
  163. 		};
  164. 	}
  166. 	const processSignals = {
  167. 		"SIGHUP": createListener(128 + 1),
  168. 		"SIGINT": createListener(128 + 2),
  169. 		"SIGTERM": createListener(128 + 15),
  170. 		"SIGBREAK": createListener(128 + 21)
  171. 	};
  173. 	for (const signal of Object.keys(processSignals)) {
  174. 		process.on(signal, processSignals[signal]);
  175. 	}
  177. 	// == TO BE DISCUSSED: Also cleanup for unhandled rejections and exceptions?
  178. 	// Add additional events like signals since they are registered on the process
  179. 	//	event emitter in a similar fashion
  180. 	// processSignals["unhandledRejection"] = createListener(1);
  181. 	// process.once("unhandledRejection", processSignals["unhandledRejection"]);
  182. 	// processSignals["uncaughtException"] = function(err, origin) {
  183. 	// 	const fs = require("fs");
  184. 	// 	fs.writeSync(
  185. 	// 		process.stderr.fd,
  186. 	// 		`Caught exception: ${err}\n` +
  187. 	// 		`Exception origin: ${origin}`
  188. 	// 	);
  189. 	// 	createListener(1)();
  190. 	// };
  191. 	// process.once("uncaughtException", processSignals["uncaughtException"]);
  193. 	return processSignals;
  194. }
  196. function deregisterCleanupSigHooks(signals) {
  197. 	for (const signal of Object.keys(signals)) {
  198. 		process.removeListener(signal, signals[signal]);
  199. 	}
  200. }
  202. /**
  203.  * Builder
  204.  *
  205.  * @public
  206.  * @namespace
  207.  * @alias module:@ui5/builder.builder
  208.  */
  209. module.exports = {
  210. 	/**
  211. 	 * Configures the project build and starts it.
  212. 	 *
  213. 	 * @public
  214. 	 * @param {object} parameters Parameters
  215. 	 * @param {object} parameters.tree Project tree as generated by the
  216. 	 * 									[@ui5/project.normalizer]{@link module:@ui5/project.normalizer}
  217. 	 * @param {string} parameters.destPath Target path
  218. 	 * @param {boolean} [parameters.cleanDest=false] Decides whether project should clean the target path before build
  219. 	 * @param {boolean} [parameters.buildDependencies=false] Decides whether project dependencies are built as well
  220. 	 * @param {Array.<string|RegExp>} [parameters.includedDependencies=[]]
  221. 	 *			List of build dependencies to be included if buildDependencies is true
  222. 	 * @param {Array.<string|RegExp>} [parameters.excludedDependencies=[]]
  223. 	 *			List of build dependencies to be excluded if buildDependencies is true.
  224. 	 *			If the wildcard '*' is provided, only the included dependencies will be built.
  225. 	 * @param {boolean} [parameters.dev=false]
  226. 	 *			Decides whether a development build should be activated (skips non-essential and time-intensive tasks)
  227. 	 * @param {boolean} [parameters.selfContained=false] Flag to activate self contained build
  228. 	 * @param {boolean} [parameters.jsdoc=false] Flag to activate JSDoc build
  229. 	 * @param {Array.<string>} [parameters.includedTasks=[]] List of tasks to be included
  230. 	 * @param {Array.<string>} [parameters.excludedTasks=[]] List of tasks to be excluded.
  231. 	 * 							If the wildcard '*' is provided, only the included tasks will be executed.
  232. 	 * @param {Array.<string>} [parameters.devExcludeProject=[]] List of projects to be excluded from development build
  233. 	 * @returns {Promise} Promise resolving to <code>undefined</code> once build has finished
  234. 	 */
  235. 	async build({
  236. 		tree, destPath, cleanDest = false,
  237. 		buildDependencies = false, includedDependencies = [], excludedDependencies = [],
  238. 		dev = false, selfContained = false, jsdoc = false,
  239. 		includedTasks = [], excludedTasks = [], devExcludeProject = []
  240. 	}) {
  241. 		const startTime = process.hrtime();
  242. 		log.info(`Building project ${tree.metadata.name}` + (buildDependencies ? "" : " not") +
  243. 			" including dependencies..." + (dev ? " [dev mode]" : ""));
  244. 		log.verbose(`Building to ${destPath}...`);
  246. 		const selectedTasks = composeTaskList({dev, selfContained, jsdoc, includedTasks, excludedTasks});
  248. 		const fsTarget = resourceFactory.createAdapter({
  249. 			fsBasePath: destPath,
  250. 			virBasePath: "/"
  251. 		});
  253. 		const buildContext = new BuildContext({rootProject: tree});
  254. 		const cleanupSigHooks = registerCleanupSigHooks(buildContext);
  256. 		const projects = {}; // Unique project index to prevent building the same project multiple times
  257. 		const projectWriters = {}; // Collection of memory adapters of already built libraries
  258. 		function projectFilter(project) {
  259. 			function projectMatchesAny(deps) {
  260. 				return deps.some((dep) => dep instanceof RegExp ?
  261. 					dep.test(project.metadata.name) : dep === project.metadata.name);
  262. 			}
  264. 			// if everything is included, this overrules exclude lists
  265. 			if (includedDependencies.includes("*")) return true;
  266. 			let test = !excludedDependencies.includes("*"); // exclude everything?
  268. 			if (test && projectMatchesAny(excludedDependencies)) {
  269. 				test = false;
  270. 			}
  271. 			if (!test && projectMatchesAny(includedDependencies)) {
  272. 				test = true;
  273. 			}
  275. 			return test;
  276. 		}
  278. 		const projectCountMarker = {};
  279. 		function projectCount(project, count = 0) {
  280. 			if (buildDependencies) {
  281. 				count = project.dependencies.filter(projectFilter).reduce((depCount, depProject) => {
  282. 					return projectCount(depProject, depCount);
  283. 				}, count);
  284. 			}
  285. 			if (!projectCountMarker[project.metadata.name]) {
  286. 				count++;
  287. 				projectCountMarker[project.metadata.name] = true;
  288. 			}
  289. 			return count;
  290. 		}
  291. 		const buildLogger = log.createTaskLogger("🛠 ", projectCount(tree));
  293. 		function buildProject(project) {
  294. 			const projectBasePath = `/resources/${project.metadata.namespace}`;
  295. 			let depPromise;
  296. 			let projectTasks = selectedTasks;
  298. 			// Build dependencies in sequence as it is far easier to detect issues and reduces
  299. 			// side effects or other issues such as too many open files
  300. 			if (buildDependencies) {
  301. 				depPromise = project.dependencies.filter(projectFilter).reduce(function(p, depProject) {
  302. 					return p.then(() => buildProject(depProject));
  303. 				}, Promise.resolve());
  304. 			} else {
  305. 				depPromise = Promise.resolve();
  306. 			}
  308. 			// Build the project after all dependencies have been built
  309. 			return depPromise.then(() => {
  310. 				if (projects[project.metadata.name]) {
  311. 					return Promise.resolve();
  312. 				} else {
  313. 					projects[project.metadata.name] = true;
  314. 				}
  315. 				buildLogger.startWork(`Building project ${project.metadata.name}`);
  317. 				const projectType = typeRepository.getType(project.type);
  318. 				const resourceCollections = resourceFactory.createCollectionsForTree(project, {
  319. 					virtualReaders: projectWriters,
  320. 					getVirtualBasePathPrefix: function({project, virBasePath}) {
  321. 						if (project.type === "application" && project.metadata.namespace) {
  322. 							return projectBasePath;
  323. 						}
  324. 					},
  325. 					getProjectExcludes: function(project) {
  326. 						if (project.builder && project.builder.resources) {
  327. 							return project.builder.resources.excludes;
  328. 						}
  329. 					}
  330. 				});
  332. 				const writer = new MemAdapter({
  333. 					virBasePath: "/"
  334. 				});
  335. 				// Store project writer as virtual reader for parent projects
  336. 				//	so they can access the build results of this project
  337. 				projectWriters[project.metadata.name] = writer;
  339. 				// TODO: Add getter for writer of DuplexColection
  340. 				const workspace = resourceFactory.createWorkspace({
  341. 					virBasePath: "/",
  342. 					writer,
  343. 					reader: resourceCollections.source,
  344. 					name: project.metadata.name
  345. 				});
  347. 				const projectContext = buildContext.createProjectContext({
  348. 					project, // TODO 2.0: Add project facade object/instance here
  349. 					resources: {
  350. 						workspace,
  351. 						dependencies: resourceCollections.dependencies
  352. 					}
  353. 				});
  355. 				const TaskUtil = require("../tasks/TaskUtil");
  356. 				const taskUtil = new TaskUtil({
  357. 					projectBuildContext: projectContext
  358. 				});
  360. 				if (dev && devExcludeProject.indexOf(project.metadata.name) !== -1) {
  361. 					projectTasks = composeTaskList({dev: false, selfContained, includedTasks, excludedTasks});
  362. 				}
  364. 				return projectType.build({
  365. 					resourceCollections: {
  366. 						workspace,
  367. 						dependencies: resourceCollections.dependencies
  368. 					},
  369. 					tasks: projectTasks,
  370. 					project,
  371. 					parentLogger: log,
  372. 					taskUtil
  373. 				}).then(() => {
  374. 					log.verbose("Finished building project %s. Writing out files...", project.metadata.name);
  375. 					buildLogger.completeWork(1);
  377. 					return workspace.byGlob("/**/*").then((resources) => {
  378. 						const tagCollection = projectContext.getResourceTagCollection();
  379. 						return Promise.all(resources.map((resource) => {
  380. 							if (tagCollection.getTag(resource, projectContext.STANDARD_TAGS.OmitFromBuildResult)) {
  381. 								log.verbose(`Skipping write of resource tagged as "OmitFromBuildResult": ` +
  382. 									resource.getPath());
  383. 								return; // Skip target write for this resource
  384. 							}
  385. 							if (projectContext.isRootProject() && project.type === "application" &&
  386. 									project.metadata.namespace) {
  387. 								// Root-application projects only: Remove namespace prefix if given
  388. 								const resourcePath = resource.getPath();
  389. 								if (resourcePath.startsWith(projectBasePath)) {
  390. 									resource.setPath(resourcePath.replace(projectBasePath, ""));
  391. 								}
  392. 							}
  393. 							return fsTarget.write(resource);
  394. 						}));
  395. 					});
  396. 				});
  397. 			});
  398. 		}
  400. 		try {
  401. 			if (cleanDest) {
  402. 				await rimraf(destPath);
  403. 			}
  404. 			await buildProject(tree);
  405. 			log.info(`Build succeeded in ${getElapsedTime(startTime)}`);
  406. 		} catch (err) {
  407. 			log.error(`Build failed in ${getElapsedTime(startTime)}`);
  408. 			throw err;
  409. 		} finally {
  410. 			deregisterCleanupSigHooks(cleanupSigHooks);
  411. 			await executeCleanupTasks(buildContext);
  412. 		}
  413. 	}
  414. };
  416. // Export local function for testing only
  417. /* istanbul ignore else */
  418. if (process.env.NODE_ENV === "test") {
  419. 	module.exports._composeTaskList = composeTaskList;
  420. }