fs/lib/adapters/FileSystem.js

  1. const log = require("@ui5/logger").getLogger("resources:adapters:FileSystem");
  2. const path = require("path");
  3. const fs = require("graceful-fs");
  4. const globby = require("globby");
  5. const makeDir = require("make-dir");
  6. const {PassThrough} = require("stream");
  7. const Resource = require("../Resource");
  8. const AbstractAdapter = require("./AbstractAdapter");
  10. /**
  11.  * File system resource adapter
  12.  *
  13.  * @public
  14.  * @alias module:@ui5/fs.adapters.FileSystem
  15.  * @augments module:@ui5/fs.adapters.AbstractAdapter
  16.  */
  17. class FileSystem extends AbstractAdapter {
  18. 	/**
  19. 	 * The Constructor.
  20. 	 *
  21. 	 * @param {object} parameters Parameters
  22. 	 * @param {string} parameters.virBasePath Virtual base path
  23. 	 * @param {string} parameters.fsBasePath (Physical) File system path
  24. 	 * @param {string[]} [parameters.excludes] List of glob patterns to exclude
  25. 	 * @param {object} [parameters.project] Experimental, internal parameter. Do not use
  26. 	 */
  27. 	constructor({virBasePath, project, fsBasePath, excludes}) {
  28. 		super({virBasePath, project, excludes});
  29. 		this._fsBasePath = fsBasePath;
  30. 	}
  32. 	/**
  33. 	 * Locate resources by glob.
  34. 	 *
  35. 	 * @private
  36. 	 * @param {Array} patterns Array of glob patterns
  37. 	 * @param {object} [options={}] glob options
  38. 	 * @param {boolean} [options.nodir=true] Do not match directories
  39. 	 * @param {module:@ui5/fs.tracing.Trace} trace Trace instance
  40. 	 * @returns {Promise<module:@ui5/fs.Resource[]>} Promise resolving to list of resources
  41. 	 */
  42. 	async _runGlob(patterns, options = {nodir: true}, trace) {
  43. 		const opt = {
  44. 			cwd: this._fsBasePath,
  45. 			dot: true,
  46. 			onlyFiles: options.nodir,
  47. 			followSymbolicLinks: false
  48. 		};
  49. 		trace.globCall();
  51. 		const promises = [];
  52. 		if (!opt.onlyFiles && patterns.includes("")) { // Match physical root directory
  53. 			promises.push(new Promise((resolve, reject) => {
  54. 				fs.stat(this._fsBasePath, (err, stat) => {
  55. 					if (err) {
  56. 						reject(err);
  57. 					} else {
  58. 						resolve(new Resource({
  59. 							project: this._project,
  60. 							statInfo: stat,
  61. 							path: this._virBaseDir,
  62. 							createStream: () => {
  63. 								return fs.createReadStream(this._fsBasePath);
  64. 							}
  65. 						}));
  66. 					}
  67. 				});
  68. 			}));
  69. 		}
  71. 		// Remove empty string glob patterns
  72. 		// Starting with globby v8 or v9 empty glob patterns "" act like "**"
  73. 		// Micromatch throws on empty strings. We just ignore them since they are
  74. 		// typically caused by our normalization in the AbstractAdapter
  75. 		const globbyPatterns = patterns.filter((pattern) => {
  76. 			return pattern !== "";
  77. 		});
  78. 		if (globbyPatterns.length > 0) {
  79. 			const matches = await globby(globbyPatterns, opt);
  80. 			for (let i = matches.length - 1; i >= 0; i--) {
  81. 				promises.push(new Promise((resolve, reject) => {
  82. 					const fsPath = path.join(this._fsBasePath, matches[i]);
  83. 					const virPath = (this._virBasePath + matches[i]);
  85. 					// Workaround for not getting the stat from the glob
  86. 					fs.stat(fsPath, (err, stat) => {
  87. 						if (err) {
  88. 							reject(err);
  89. 						} else {
  90. 							resolve(new Resource({
  91. 								project: this._project,
  92. 								statInfo: stat,
  93. 								path: virPath,
  94. 								createStream: () => {
  95. 									return fs.createReadStream(fsPath);
  96. 								}
  97. 							}));
  98. 						}
  99. 					});
  100. 				}));
  101. 			}
  102. 		}
  103. 		const results = await Promise.all(promises);
  105. 		// Flatten results
  106. 		return Array.prototype.concat.apply([], results);
  107. 	}
  109. 	/**
  110. 	 * Locate a resource by path.
  111. 	 *
  112. 	 * @private
  113. 	 * @param {string} virPath Virtual path
  114. 	 * @param {object} options Options
  115. 	 * @param {module:@ui5/fs.tracing.Trace} trace Trace instance
  116. 	 * @returns {Promise<module:@ui5/fs.Resource>} Promise resolving to a single resource or null if not found
  117. 	 */
  118. 	_byPath(virPath, options, trace) {
  119. 		if (this.isPathExcluded(virPath)) {
  120. 			return Promise.resolve(null);
  121. 		}
  123. 		return new Promise((resolve, reject) => {
  124. 			if (!virPath.startsWith(this._virBasePath) && virPath !== this._virBaseDir) {
  125. 				// Neither starts with basePath, nor equals baseDirectory
  126. 				if (!options.nodir && this._virBasePath.startsWith(virPath)) {
  127. 					resolve(new Resource({
  128. 						project: this._project,
  129. 						statInfo: { // TODO: make closer to fs stat info
  130. 							isDirectory: function() {
  131. 								return true;
  132. 							}
  133. 						},
  134. 						path: virPath
  135. 					}));
  136. 				} else {
  137. 					resolve(null);
  138. 				}
  140. 				return;
  141. 			}
  142. 			const relPath = virPath.substr(this._virBasePath.length);
  143. 			const fsPath = path.join(this._fsBasePath, relPath);
  145. 			trace.pathCall();
  146. 			fs.stat(fsPath, (err, stat) => {
  147. 				if (err) {
  148. 					if (err.code === "ENOENT") { // "File or directory does not exist"
  149. 						resolve(null);
  150. 					} else {
  151. 						reject(err);
  152. 					}
  153. 				} else if (options.nodir && stat.isDirectory()) {
  154. 					resolve(null);
  155. 				} else {
  156. 					const options = {
  157. 						project: this._project,
  158. 						statInfo: stat,
  159. 						path: virPath,
  160. 						fsPath
  161. 					};
  163. 					if (!stat.isDirectory()) {
  164. 						// Add content
  165. 						options.createStream = function() {
  166. 							return fs.createReadStream(fsPath);
  167. 						};
  168. 					}
  170. 					resolve(new Resource(options));
  171. 				}
  172. 			});
  173. 		});
  174. 	}
  176. 	/**
  177. 	 * Writes the content of a resource to a path.
  178. 	 *
  179. 	 * @private
  180. 	 * @param {module:@ui5/fs.Resource} resource Resource to write
  181. 	 * @param {object} [options]
  182. 	 * @param {boolean} [options.readOnly] Whether the resource content shall be written read-only
  183. 	 *						Do not use in conjunction with the <code>drain</code> option.
  184. 	 *						The written file will be used as the new source of this resources content.
  185. 	 *						Therefore the written file should not be altered by any means.
  186. 	 *						Activating this option might improve overall memory consumption.
  187. 	 * @param {boolean} [options.drain] Whether the resource content shall be emptied during the write process.
  188. 	 *						Do not use in conjunction with the <code>readOnly</code> option.
  189. 	 *						Activating this option might improve overall memory consumption.
  190. 	 *						This should be used in cases where this is the last access to the resource.
  191. 	 *						E.g. the final write of a resource after all processing is finished.
  192. 	 * @returns {Promise<undefined>} Promise resolving once data has been written
  193. 	 */
  194. 	async _write(resource, {drain, readOnly}) {
  195. 		if (drain && readOnly) {
  196. 			throw new Error(`Error while writing resource ${resource.getPath()}: ` +
  197. 				"Do not use options 'drain' and 'readOnly' at the same time.");
  198. 		}
  200. 		const relPath = resource.getPath().substr(this._virBasePath.length);
  201. 		const fsPath = path.join(this._fsBasePath, relPath);
  202. 		const dirPath = path.dirname(fsPath);
  204. 		log.verbose("Writing to %s", fsPath);
  206. 		await makeDir(dirPath, {fs});
  207. 		return new Promise((resolve, reject) => {
  208. 			let contentStream;
  210. 			if (drain || readOnly) {
  211. 				// Stream will be drained
  212. 				contentStream = resource.getStream();
  214. 				contentStream.on("error", (err) => {
  215. 					reject(err);
  216. 				});
  217. 			} else {
  218. 				// Transform stream into buffer before writing
  219. 				contentStream = new PassThrough();
  220. 				const buffers = [];
  221. 				contentStream.on("error", (err) => {
  222. 					reject(err);
  223. 				});
  224. 				contentStream.on("data", (data) => {
  225. 					buffers.push(data);
  226. 				});
  227. 				contentStream.on("end", () => {
  228. 					const buffer = Buffer.concat(buffers);
  229. 					resource.setBuffer(buffer);
  230. 				});
  231. 				resource.getStream().pipe(contentStream);
  232. 			}
  234. 			const writeOptions = {};
  235. 			if (readOnly) {
  236. 				writeOptions.mode = 0o444; // read only
  237. 			}
  239. 			const write = fs.createWriteStream(fsPath, writeOptions);
  240. 			write.on("error", (err) => {
  241. 				reject(err);
  242. 			});
  243. 			write.on("close", (ex) => {
  244. 				if (readOnly) {
  245. 					// Create new stream from written file
  246. 					resource.setStream(function() {
  247. 						return fs.createReadStream(fsPath);
  248. 					});
  249. 				}
  250. 				resolve();
  251. 			});
  252. 			contentStream.pipe(write);
  253. 		});
  254. 	}
  255. }
  257. module.exports = FileSystem;