server/lib/server.js

  1. import express from "express";
  2. import portscanner from "portscanner";
  3. import MiddlewareManager from "./middleware/MiddlewareManager.js";
  4. import {createReaderCollection} from "@ui5/fs/resourceFactory";
  5. import ReaderCollectionPrioritized from "@ui5/fs/ReaderCollectionPrioritized";
  7. /**
  8.  * @public
  9.  * @module @ui5/server
  10.  */
  12. /**
  13.  * Returns a promise resolving by starting the server.
  14.  *
  15.  * @param {object} app The express application object
  16.  * @param {number} port Desired port to listen to
  17.  * @param {boolean} changePortIfInUse If true and the port is already in use, an unused port is searched
  18.  * @param {boolean} acceptRemoteConnections If true, listens to remote connections and not only to localhost connections
  19.  * @returns {Promise<object>} Returns an object containing server related information like (selected port, protocol)
  20.  * @private
  21.  */
  22. function _listen(app, port, changePortIfInUse, acceptRemoteConnections) {
  23. 	return new Promise(function(resolve, reject) {
  24. 		const options = {};
  26. 		if (!acceptRemoteConnections) {
  27. 			options.host = "localhost";
  28. 		}
  30. 		const host = options.host || "127.0.0.1";
  31. 		let portMax;
  32. 		if (changePortIfInUse) {
  33. 			portMax = port + 30;
  34. 		} else {
  35. 			portMax = port;
  36. 		}
  38. 		portscanner.findAPortNotInUse(port, portMax, host, function(error, foundPort) {
  39. 			if (error) {
  40. 				reject(error);
  41. 				return;
  42. 			}
  44. 			if (!foundPort) {
  45. 				if (changePortIfInUse) {
  46. 					const error = new Error(
  47. 						`EADDRINUSE: Could not find available ports between ${port} and ${portMax}.`);
  48. 					error.code = "EADDRINUSE";
  49. 					error.errno = "EADDRINUSE";
  50. 					error.address = host;
  51. 					error.port = portMax;
  52. 					reject(error);
  53. 					return;
  54. 				} else {
  55. 					const error = new Error(`EADDRINUSE: Port ${port} is already in use.`);
  56. 					error.code = "EADDRINUSE";
  57. 					error.errno = "EADDRINUSE";
  58. 					error.address = host;
  59. 					error.port = portMax;
  60. 					reject(error);
  61. 					return;
  62. 				}
  63. 			}
  65. 			options.port = foundPort;
  66. 			const server = app.listen(options, function() {
  67. 				resolve({port: options.port, server});
  68. 			});
  70. 			server.on("error", function(err) {
  71. 				reject(err);
  72. 			});
  73. 		});
  74. 	});
  75. }
  77. /**
  78.  * Adds SSL support to an express application.
  79.  *
  80.  * @param {object} parameters
  81.  * @param {object} parameters.app The original express application
  82.  * @param {string} parameters.key Path to private key to be used for https
  83.  * @param {string} parameters.cert Path to certificate to be used for for https
  84.  * @returns {Promise<object>} The express application with SSL support
  85.  * @private
  86.  */
  87. async function _addSsl({app, key, cert}) {
  88. 	// Using spdy as http2 server as the native http2 implementation
  89. 	// from Node v8.4.0 doesn't seem to work with express
  90. 	const {default: spdy} = await import("spdy");
  91. 	return spdy.createServer({cert, key}, app);
  92. }
  95. /**
  96.  * SAP target CSP middleware options
  97.  *
  98.  * @public
  99.  * @typedef {object} module:@ui5/server.SAPTargetCSPOptions
  100.  * @property {string} [defaultPolicy="sap-target-level-1"]
  101.  * @property {string} [defaultPolicyIsReportOnly=true]
  102.  * @property {string} [defaultPolicy2="sap-target-level-3"]
  103.  * @property {string} [defaultPolicy2IsReportOnly=true]
  104.  * @property {string[]} [ignorePaths=["test-resources/sap/ui/qunit/testrunner.html"]]
  105.  */
  108. /**
  109.  * Start a server for the given project (sub-)tree.
  110.  *
  111.  * @public
  112.  * @param {@ui5/project/graph/ProjectGraph} graph Project graph
  113.  * @param {object} options Options
  114.  * @param {number} options.port Port to listen to
  115.  * @param {boolean} [options.changePortIfInUse=false] If true, change the port if it is already in use
  116.  * @param {boolean} [options.h2=false] Whether HTTP/2 should be used - defaults to <code>http</code>
  117.  * @param {string} [options.key] Path to private key to be used for https
  118.  * @param {string} [options.cert] Path to certificate to be used for for https
  119.  * @param {boolean} [options.simpleIndex=false] Use a simplified view for the server directory listing
  120.  * @param {boolean} [options.acceptRemoteConnections=false] If true, listens to remote connections and
  121.  * 															not only to localhost connections
  122.  * @param {boolean|module:@ui5/server.SAPTargetCSPOptions} [options.sendSAPTargetCSP=false]
  123.  * 										If set to <code>true</code> or an object, then the default (or configured)
  124.  * 										set of security policies that SAP and UI5 aim for (AKA 'target policies'),
  125.  * 										are send for any requested <code>*.html</code> file
  126.  * @param {boolean} [options.serveCSPReports=false] Enable CSP reports serving for request url
  127.  * 										'/.ui5/csp/csp-reports.json'
  128.  * @returns {Promise<object>} Promise resolving once the server is listening.
  129.  * 							It resolves with an object containing the <code>port</code>,
  130.  * 							<code>h2</code>-flag and a <code>close</code> function,
  131.  * 							which can be used to stop the server.
  132.  */
  133. export async function serve(graph, {
  134. 	port: requestedPort, changePortIfInUse = false, h2 = false, key, cert,
  135. 	acceptRemoteConnections = false, sendSAPTargetCSP = false, simpleIndex = false, serveCSPReports = false
  136. }) {
  137. 	const rootProject = graph.getRoot();
  139. 	const readers = [];
  140. 	await graph.traverseBreadthFirst(async function({project: dep}) {
  141. 		if (dep.getName() === rootProject.getName()) {
  142. 			// Ignore root project
  143. 			return;
  144. 		}
  145. 		readers.push(dep.getReader({style: "runtime"}));
  146. 	});
  148. 	const dependencies = createReaderCollection({
  149. 		name: `Dependency reader collection for project ${rootProject.getName()}`,
  150. 		readers
  151. 	});
  153. 	const rootReader = rootProject.getReader({style: "runtime"});
  155. 	// TODO change to ReaderCollection once duplicates are sorted out
  156. 	const combo = new ReaderCollectionPrioritized({
  157. 		name: "server - prioritize workspace over dependencies",
  158. 		readers: [rootReader, dependencies]
  159. 	});
  160. 	const resources = {
  161. 		rootProject: rootReader,
  162. 		dependencies: dependencies,
  163. 		all: combo
  164. 	};
  166. 	const middlewareManager = new MiddlewareManager({
  167. 		graph,
  168. 		rootProject,
  169. 		resources,
  170. 		options: {
  171. 			sendSAPTargetCSP,
  172. 			serveCSPReports,
  173. 			simpleIndex
  174. 		}
  175. 	});
  177. 	let app = express();
  178. 	await middlewareManager.applyMiddleware(app);
  180. 	if (h2) {
  181. 		app = await _addSsl({app, key, cert});
  182. 	}
  184. 	const {port, server} = await _listen(app, requestedPort, changePortIfInUse, acceptRemoteConnections);
  186. 	return {
  187. 		h2,
  188. 		port,
  189. 		close: function(callback) {
  190. 			server.close(callback);
  191. 		}
  192. 	};
  193. }