httpServer.js 6.6 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195
  1. "use strict";
  2. Object.defineProperty(exports, "__esModule", {
  3. value: true
  4. });
  5. exports.HttpServer = void 0;
  6. var _fs = _interopRequireDefault(require("fs"));
  7. var _path = _interopRequireDefault(require("path"));
  8. var _utilsBundle = require("../utilsBundle");
  9. var _debug = require("./debug");
  10. var _network = require("./network");
  11. var _manualPromise = require("./manualPromise");
  12. function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
  13. /**
  14. * Copyright (c) Microsoft Corporation.
  15. *
  16. * Licensed under the Apache License, Version 2.0 (the "License");
  17. * you may not use this file except in compliance with the License.
  18. * You may obtain a copy of the License at
  19. *
  20. * http://www.apache.org/licenses/LICENSE-2.0
  21. *
  22. * Unless required by applicable law or agreed to in writing, software
  23. * distributed under the License is distributed on an "AS IS" BASIS,
  24. * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  25. * See the License for the specific language governing permissions and
  26. * limitations under the License.
  27. */
  28. class HttpServer {
  29. constructor(address = '') {
  30. this._server = void 0;
  31. this._urlPrefix = void 0;
  32. this._port = 0;
  33. this._started = false;
  34. this._routes = [];
  35. this._urlPrefix = address;
  36. this._server = (0, _network.createHttpServer)(this._onRequest.bind(this));
  37. }
  38. server() {
  39. return this._server;
  40. }
  41. routePrefix(prefix, handler) {
  42. this._routes.push({
  43. prefix,
  44. handler
  45. });
  46. }
  47. routePath(path, handler) {
  48. this._routes.push({
  49. exact: path,
  50. handler
  51. });
  52. }
  53. port() {
  54. return this._port;
  55. }
  56. async _tryStart(port, host) {
  57. const errorPromise = new _manualPromise.ManualPromise();
  58. const errorListener = error => errorPromise.reject(error);
  59. this._server.on('error', errorListener);
  60. try {
  61. this._server.listen(port, host);
  62. await Promise.race([new Promise(cb => this._server.once('listening', cb)), errorPromise]);
  63. } finally {
  64. this._server.removeListener('error', errorListener);
  65. }
  66. }
  67. async start(options = {}) {
  68. (0, _debug.assert)(!this._started, 'server already started');
  69. this._started = true;
  70. const host = options.host || 'localhost';
  71. if (options.preferredPort) {
  72. try {
  73. await this._tryStart(options.preferredPort, host);
  74. } catch (e) {
  75. if (!e || !e.message || !e.message.includes('EADDRINUSE')) throw e;
  76. await this._tryStart(undefined, host);
  77. }
  78. } else {
  79. await this._tryStart(options.port, host);
  80. }
  81. const address = this._server.address();
  82. (0, _debug.assert)(address, 'Could not bind server socket');
  83. if (!this._urlPrefix) {
  84. if (typeof address === 'string') {
  85. this._urlPrefix = address;
  86. } else {
  87. this._port = address.port;
  88. this._urlPrefix = `http://${host}:${address.port}`;
  89. }
  90. }
  91. return this._urlPrefix;
  92. }
  93. async stop() {
  94. await new Promise(cb => this._server.close(cb));
  95. }
  96. urlPrefix() {
  97. return this._urlPrefix;
  98. }
  99. serveFile(request, response, absoluteFilePath, headers) {
  100. try {
  101. for (const [name, value] of Object.entries(headers || {})) response.setHeader(name, value);
  102. if (request.headers.range) this._serveRangeFile(request, response, absoluteFilePath);else this._serveFile(response, absoluteFilePath);
  103. return true;
  104. } catch (e) {
  105. return false;
  106. }
  107. }
  108. _serveFile(response, absoluteFilePath) {
  109. const content = _fs.default.readFileSync(absoluteFilePath);
  110. response.statusCode = 200;
  111. const contentType = _utilsBundle.mime.getType(_path.default.extname(absoluteFilePath)) || 'application/octet-stream';
  112. response.setHeader('Content-Type', contentType);
  113. response.setHeader('Content-Length', content.byteLength);
  114. response.end(content);
  115. }
  116. _serveRangeFile(request, response, absoluteFilePath) {
  117. const range = request.headers.range;
  118. if (!range || !range.startsWith('bytes=') || range.includes(', ') || [...range].filter(char => char === '-').length !== 1) {
  119. response.statusCode = 400;
  120. return response.end('Bad request');
  121. }
  122. // Parse the range header: https://datatracker.ietf.org/doc/html/rfc7233#section-2.1
  123. const [startStr, endStr] = range.replace(/bytes=/, '').split('-');
  124. // Both start and end (when passing to fs.createReadStream) and the range header are inclusive and start counting at 0.
  125. let start;
  126. let end;
  127. const size = _fs.default.statSync(absoluteFilePath).size;
  128. if (startStr !== '' && endStr === '') {
  129. // No end specified: use the whole file
  130. start = +startStr;
  131. end = size - 1;
  132. } else if (startStr === '' && endStr !== '') {
  133. // No start specified: calculate start manually
  134. start = size - +endStr;
  135. end = size - 1;
  136. } else {
  137. start = +startStr;
  138. end = +endStr;
  139. }
  140. // Handle unavailable range request
  141. if (Number.isNaN(start) || Number.isNaN(end) || start >= size || end >= size || start > end) {
  142. // Return the 416 Range Not Satisfiable: https://datatracker.ietf.org/doc/html/rfc7233#section-4.4
  143. response.writeHead(416, {
  144. 'Content-Range': `bytes */${size}`
  145. });
  146. return response.end();
  147. }
  148. // Sending Partial Content: https://datatracker.ietf.org/doc/html/rfc7233#section-4.1
  149. response.writeHead(206, {
  150. 'Content-Range': `bytes ${start}-${end}/${size}`,
  151. 'Accept-Ranges': 'bytes',
  152. 'Content-Length': end - start + 1,
  153. 'Content-Type': _utilsBundle.mime.getType(_path.default.extname(absoluteFilePath))
  154. });
  155. const readable = _fs.default.createReadStream(absoluteFilePath, {
  156. start,
  157. end
  158. });
  159. readable.pipe(response);
  160. }
  161. _onRequest(request, response) {
  162. response.setHeader('Access-Control-Allow-Origin', '*');
  163. response.setHeader('Access-Control-Request-Method', '*');
  164. response.setHeader('Access-Control-Allow-Methods', 'OPTIONS, GET');
  165. if (request.headers.origin) response.setHeader('Access-Control-Allow-Headers', request.headers.origin);
  166. if (request.method === 'OPTIONS') {
  167. response.writeHead(200);
  168. response.end();
  169. return;
  170. }
  171. request.on('error', () => response.end());
  172. try {
  173. if (!request.url) {
  174. response.end();
  175. return;
  176. }
  177. const url = new URL('http://localhost' + request.url);
  178. for (const route of this._routes) {
  179. if (route.exact && url.pathname === route.exact && route.handler(request, response)) return;
  180. if (route.prefix && url.pathname.startsWith(route.prefix) && route.handler(request, response)) return;
  181. }
  182. response.statusCode = 404;
  183. response.end();
  184. } catch (e) {
  185. response.end();
  186. }
  187. }
  188. }
  189. exports.HttpServer = HttpServer;