treeherder/web-server.js

#!/usr/bin/env node

var util = require('util'),
    http = require('http'),
    fs = require('fs'),
    path = require('path'),
    url = require('url'),
    events = require('events');

var DEFAULT_PORT = 8000;
var APP_ROOT = path.join(__dirname, "ui");
var INDEX_FILE = 'index.html';

function main(argv) {
  new HttpServer({
    'GET': createServlet(StaticServlet),
    'HEAD': createServlet(StaticServlet)
  }).start(Number(argv[2]) || DEFAULT_PORT);
}

function escapeHtml(value) {
  return value.toString().
    replace('<', '&lt;').
    replace('>', '&gt;').
    replace('"', '&quot;');
}

function createServlet(Class) {
  var servlet = new Class();
  return servlet.handleRequest.bind(servlet);
}

/**
 * An Http server implementation that uses a map of methods to decide
 * action routing.
 *
 * @param {Object} Map of method => Handler function
 */
function HttpServer(handlers) {
  this.handlers = handlers;
  this.server = http.createServer(this.handleRequest_.bind(this));
}

HttpServer.prototype.start = function(port) {
  this.port = port;
  console.log("Starting web server at http://localhost:" + port + "/");
  this.server.listen(port).on('error', function(err) {
    if (err.code === "EADDRINUSE") {
      console.error("\033[31mPort %d is already in use, can't start web server.\033[0m", port);
    }
  });
};

HttpServer.prototype.parseUrl_ = function(urlString) {
  var parsed = url.parse(urlString);
  parsed.pathname = url.resolve('/', parsed.pathname);
  return url.parse(url.format(parsed), true);
};

HttpServer.prototype.handleRequest_ = function(req, res) {
  var logEntry = req.method + ' ' + req.url;
  if (req.headers['user-agent']) {
    logEntry += ' ' + req.headers['user-agent'];
  }
  util.puts(logEntry);
  req.url = this.parseUrl_(req.url);
  var handler = this.handlers[req.method];
  if (!handler) {
    res.writeHead(501);
    res.end();
  } else {
    handler.call(this, req, res);
  }
};

/**
 * Handles static content.
 */
function StaticServlet() {}

StaticServlet.MimeMap = {
  'txt': 'text/plain',
  'html': 'text/html',
  'css': 'text/css',
  'xml': 'application/xml',
  'json': 'application/json',
  'js': 'application/javascript',
  'jpg': 'image/jpeg',
  'jpeg': 'image/jpeg',
  'gif': 'image/gif',
  'png': 'image/png',
  'svg': 'image/svg+xml'
};

StaticServlet.prototype.handleRequest = function(req, res) {
  var self = this;
  var path = (APP_ROOT + req.url.pathname).replace('//','/').replace(/%(..)/g, function(match, hex){
    return String.fromCharCode(parseInt(hex, 16));
  });
  var parts = path.split('/');
  if (parts[parts.length-1].charAt(0) === '.')
    return self.sendForbidden_(req, res, path);
  fs.stat(path, function(err, stat) {
    if (err)
      return self.sendMissing_(req, res, path);
    if (stat.isDirectory())
      return self.handleDirectoryRequest_(req, res, path);
    return self.sendFile_(req, res, path);
  });
};

StaticServlet.prototype.handleDirectoryRequest_ = function(req, res, path) {
  var self = this;
  if (path.match(/[^\/]$/)) {
    req.url.pathname += '/';
    var redirectUrl = url.format(url.parse(url.format(req.url)));
    return self.sendRedirect_(req, res, redirectUrl);
  }
  // Check if there is an index file (eg index.html) we can serve.
  var indexpath = path + INDEX_FILE;
  fs.stat(indexpath, function(err, stat) {
    if (stat && stat.isFile())
      return self.sendFile_(req, res, indexpath);
    // Otherwise just display the directory listing.
    return self.sendDirectory_(req, res, path);
  });
};

StaticServlet.prototype.sendError_ = function(req, res, error) {
  res.writeHead(500, {
      'Content-Type': 'text/html'
  });
  res.write('<!doctype html>\n');
  res.write('<title>Internal Server Error</title>\n');
  res.write('<h1>Internal Server Error</h1>');
  res.write('<pre>' + escapeHtml(util.inspect(error)) + '</pre>');
  util.puts('500 Internal Server Error');
  util.puts(util.inspect(error));
};

StaticServlet.prototype.sendMissing_ = function(req, res, path) {
  path = path.substring(1);
  res.writeHead(404, {
      'Content-Type': 'text/html'
  });
  res.write('<!doctype html>\n');
  res.write('<title>404 Not Found</title>\n');
  res.write('<h1>Not Found</h1>');
  res.write(
    '<p>The requested URL ' +
    escapeHtml(path) +
    ' was not found on this server.</p>'
  );
  res.end();
  util.puts('404 Not Found: ' + path);
};

StaticServlet.prototype.sendForbidden_ = function(req, res, path) {
  path = path.substring(1);
  res.writeHead(403, {
      'Content-Type': 'text/html'
  });
  res.write('<!doctype html>\n');
  res.write('<title>403 Forbidden</title>\n');
  res.write('<h1>Forbidden</h1>');
  res.write(
    '<p>You do not have permission to access ' +
    escapeHtml(path) + ' on this server.</p>'
  );
  res.end();
  util.puts('403 Forbidden: ' + path);
};

StaticServlet.prototype.sendRedirect_ = function(req, res, redirectUrl) {
  res.writeHead(301, {
      'Content-Type': 'text/html',
      'Location': redirectUrl
  });
  res.write('<!doctype html>\n');
  res.write('<title>301 Moved Permanently</title>\n');
  res.write('<h1>Moved Permanently</h1>');
  res.write(
    '<p>The document has moved <a href="' +
    redirectUrl +
    '">here</a>.</p>'
  );
  res.end();
  util.puts('301 Moved Permanently: ' + redirectUrl);
};

StaticServlet.prototype.sendFile_ = function(req, res, path) {
  var self = this;
  var file = fs.createReadStream(path);
  res.writeHead(200, {
    'Content-Type': StaticServlet.
      MimeMap[path.split('.').pop()] || 'text/plain'
  });
  if (req.method === 'HEAD') {
    res.end();
  } else {
    file.on('data', res.write.bind(res));
    file.on('close', function() {
      res.end();
    });
    file.on('error', function(error) {
      self.sendError_(req, res, error);
    });
  }
};

StaticServlet.prototype.sendDirectory_ = function(req, res, path) {
  var self = this;
  fs.readdir(path, function(err, files) {
    if (err)
      return self.sendError_(req, res, error);

    if (!files.length)
      return self.writeDirectoryIndex_(req, res, path, []);

    var remaining = files.length;
    files.forEach(function(fileName, index) {
      fs.stat(path + '/' + fileName, function(err, stat) {
        if (err)
          return self.sendError_(req, res, err);
        if (stat.isDirectory()) {
          files[index] = fileName + '/';
        }
        if (!(--remaining))
          return self.writeDirectoryIndex_(req, res, path, files);
      });
    });
  });
};

StaticServlet.prototype.writeDirectoryIndex_ = function(req, res, path, files) {
  path = path.substring(1);
  res.writeHead(200, {
    'Content-Type': 'text/html'
  });
  if (req.method === 'HEAD') {
    res.end();
    return;
  }
  res.write('<!doctype html>\n');
  res.write('<title>' + escapeHtml(path) + '</title>\n');
  res.write('<style>\n');
  res.write('  ol { list-style-type: none; font-size: 1.2em; }\n');
  res.write('</style>\n');
  res.write('<h1>Directory: ' + escapeHtml(path) + '</h1>');
  res.write('<ol>');
  files.forEach(function(fileName) {
    if (fileName.charAt(0) !== '.') {
      res.write('<li><a href="' +
        escapeHtml(fileName) + '">' +
        escapeHtml(fileName) + '</a></li>');
    }
  });
  res.write('</ol>');
  res.end();
};

function isFile(filename) {
  try {
    if (!fs.statSync(filename).isFile())
      throw("not a file");
  } catch (e) {
    return false;
  }
  return true;
}


// All the HTML files include the config file directly but none of them warns
// if it doesn't exist, so when starting the server is a good time to warn.
var confFile = path.join(APP_ROOT, "js", "config", "local.conf.js");
if (!isFile(confFile)) {
  console.log("Missing config file '" + confFile + "'.\n" +
              "Consider copying it from 'sample.local.conf.js' at the same directory.");
}

// Must be last,
main(process.argv);
-												add angular webapp skeleton

											
										
										
											2013-07-11 21:52:04 +04:00
+								#!/usr/bin/env node
 								var util = require('util'),
 								    http = require('http'),
 								    fs = require('fs'),
-												Bug 1160359 - web-server: init: check config file, fix app root

* warn if local.conf.js doesn't exist and suggest the sample config
* set the web root relative to the server script such that it can be
  invoked from anywhere and keep the serving the same URLs

it seems that stat[Sync] is more likely to stay than exists[Sync] on path or fs
see http://stackoverflow.com/a/4482701/3339341

											
										
										
											2015-04-24 09:12:26 +03:00
+								    path = require('path'),
-												add angular webapp skeleton

											
										
										
											2013-07-11 21:52:04 +04:00
+								    url = require('url'),
 								    events = require('events');
 								var DEFAULT_PORT = 8000;
-												Bug 1056877 - Update UI path references after directory moves

As part of merging the UI repo into this one, the following directory
moves were performed:
  webapp/app/                   ->  ui/
  webapp/test/                  ->  tests/ui/
  webapp/config/                ->  tests/ui/config/
  webapp/scripts/               ->  tests/ui/scripts/
  webapp/scripts/web-server.js  ->  web-server.js

											
										
										
											2015-05-18 18:00:59 +03:00
+								var APP_ROOT = path.join(__dirname, "ui");
-												Bug 1168770 - web-server.js: Serve index.html by default, if present

Instead of always displaying the directory file listing, if index.html
is present we serve that instead. This not only fixes the remaining
broken URLs when using web-server.js, but also means people can click
the "Starting web server at <URL>" link in the console and immediately
see Treeherder, without having to then manually navigate to index.html
themselves.

											
										
										
											2015-05-27 14:22:58 +03:00
+								var INDEX_FILE = 'index.html';
-												add angular webapp skeleton

											
										
										
											2013-07-11 21:52:04 +04:00
 								function main(argv) {
 								  new HttpServer({
 								    'GET': createServlet(StaticServlet),
 								    'HEAD': createServlet(StaticServlet)
 								  }).start(Number(argv[2]) || DEFAULT_PORT);
 								}
 								function escapeHtml(value) {
 								  return value.toString().
 								    replace('<', '&lt;').
 								    replace('>', '&gt;').
 								    replace('"', '&quot;');
 								}
 								function createServlet(Class) {
 								  var servlet = new Class();
 								  return servlet.handleRequest.bind(servlet);
 								}
 								/**
 								 * An Http server implementation that uses a map of methods to decide
 								 * action routing.
 								 *
 								 * @param {Object} Map of method => Handler function
 								 */
 								function HttpServer(handlers) {
 								  this.handlers = handlers;
 								  this.server = http.createServer(this.handleRequest_.bind(this));
 								}
 								HttpServer.prototype.start = function(port) {
 								  this.port = port;
-												Bug 1141203 - Print a friendly error message when port is already in use when web-server.js is run.

Adds a simple 'error' event listener to HttpServer.start. If
error code is "EADDRINUSE", the port is already in use, so prints
a message saying the port is in use, instead of just throwing out
the error.

											
										
										
											2015-04-14 21:13:43 +03:00
+								  console.log("Starting web server at http://localhost:" + port + "/");
 								  this.server.listen(port).on('error', function(err) {
 								    if (err.code === "EADDRINUSE") {
-												Bug 1141203 - Change terminal color back to normal after printing error.

											
										
										
											2015-04-14 23:02:29 +03:00
+								      console.error("\033[31mPort %d is already in use, can't start web server.\033[0m", port);
-												Bug 1141203 - Print a friendly error message when port is already in use when web-server.js is run.

Adds a simple 'error' event listener to HttpServer.start. If
error code is "EADDRINUSE", the port is already in use, so prints
a message saying the port is in use, instead of just throwing out
the error.

											
										
										
											2015-04-14 21:13:43 +03:00
+								    }
 								  });
-												add angular webapp skeleton

											
										
										
											2013-07-11 21:52:04 +04:00
+								};
 								HttpServer.prototype.parseUrl_ = function(urlString) {
 								  var parsed = url.parse(urlString);
 								  parsed.pathname = url.resolve('/', parsed.pathname);
 								  return url.parse(url.format(parsed), true);
 								};
 								HttpServer.prototype.handleRequest_ = function(req, res) {
 								  var logEntry = req.method + ' ' + req.url;
 								  if (req.headers['user-agent']) {
 								    logEntry += ' ' + req.headers['user-agent'];
 								  }
 								  util.puts(logEntry);
 								  req.url = this.parseUrl_(req.url);
 								  var handler = this.handlers[req.method];
 								  if (!handler) {
 								    res.writeHead(501);
 								    res.end();
 								  } else {
 								    handler.call(this, req, res);
 								  }
 								};
 								/**
 								 * Handles static content.
 								 */
 								function StaticServlet() {}
 								StaticServlet.MimeMap = {
 								  'txt': 'text/plain',
 								  'html': 'text/html',
 								  'css': 'text/css',
 								  'xml': 'application/xml',
 								  'json': 'application/json',
 								  'js': 'application/javascript',
 								  'jpg': 'image/jpeg',
 								  'jpeg': 'image/jpeg',
 								  'gif': 'image/gif',
 								  'png': 'image/png',
 								  'svg': 'image/svg+xml'
 								};
 								StaticServlet.prototype.handleRequest = function(req, res) {
 								  var self = this;
-												Bug 1160359 - web-server: init: check config file, fix app root

* warn if local.conf.js doesn't exist and suggest the sample config
* set the web root relative to the server script such that it can be
  invoked from anywhere and keep the serving the same URLs

it seems that stat[Sync] is more likely to stay than exists[Sync] on path or fs
see http://stackoverflow.com/a/4482701/3339341

											
										
										
											2015-04-24 09:12:26 +03:00
+								  var path = (APP_ROOT + req.url.pathname).replace('//','/').replace(/%(..)/g, function(match, hex){
-												add angular webapp skeleton

											
										
										
											2013-07-11 21:52:04 +04:00
+								    return String.fromCharCode(parseInt(hex, 16));
 								  });
 								  var parts = path.split('/');
 								  if (parts[parts.length-1].charAt(0) === '.')
 								    return self.sendForbidden_(req, res, path);
 								  fs.stat(path, function(err, stat) {
 								    if (err)
 								      return self.sendMissing_(req, res, path);
 								    if (stat.isDirectory())
-												Bug 1168770 - web-server.js: Move directory handling to its own function

Since we're about to add index.html support on top.

											
										
										
											2015-05-27 13:22:33 +03:00
+								      return self.handleDirectoryRequest_(req, res, path);
-												add angular webapp skeleton

											
										
										
											2013-07-11 21:52:04 +04:00
+								    return self.sendFile_(req, res, path);
 								  });
-												Bug 1168770 - web-server.js: Move directory handling to its own function

Since we're about to add index.html support on top.

											
										
										
											2015-05-27 13:22:33 +03:00
+								};
 								StaticServlet.prototype.handleDirectoryRequest_ = function(req, res, path) {
 								  var self = this;
 								  if (path.match(/[^\/]$/)) {
 								    req.url.pathname += '/';
 								    var redirectUrl = url.format(url.parse(url.format(req.url)));
 								    return self.sendRedirect_(req, res, redirectUrl);
 								  }
-												Bug 1168770 - web-server.js: Serve index.html by default, if present

Instead of always displaying the directory file listing, if index.html
is present we serve that instead. This not only fixes the remaining
broken URLs when using web-server.js, but also means people can click
the "Starting web server at <URL>" link in the console and immediately
see Treeherder, without having to then manually navigate to index.html
themselves.

											
										
										
											2015-05-27 14:22:58 +03:00
+								  // Check if there is an index file (eg index.html) we can serve.
 								  var indexpath = path + INDEX_FILE;
 								  fs.stat(indexpath, function(err, stat) {
 								    if (stat && stat.isFile())
 								      return self.sendFile_(req, res, indexpath);
 								    // Otherwise just display the directory listing.
 								    return self.sendDirectory_(req, res, path);
 								  });
-												Bug 1168770 - web-server.js: Move directory handling to its own function

Since we're about to add index.html support on top.

											
										
										
											2015-05-27 13:22:33 +03:00
+								};
-												add angular webapp skeleton

											
										
										
											2013-07-11 21:52:04 +04:00
 								StaticServlet.prototype.sendError_ = function(req, res, error) {
 								  res.writeHead(500, {
 								      'Content-Type': 'text/html'
 								  });
 								  res.write('<!doctype html>\n');
 								  res.write('<title>Internal Server Error</title>\n');
 								  res.write('<h1>Internal Server Error</h1>');
 								  res.write('<pre>' + escapeHtml(util.inspect(error)) + '</pre>');
 								  util.puts('500 Internal Server Error');
 								  util.puts(util.inspect(error));
 								};
 								StaticServlet.prototype.sendMissing_ = function(req, res, path) {
 								  path = path.substring(1);
 								  res.writeHead(404, {
 								      'Content-Type': 'text/html'
 								  });
 								  res.write('<!doctype html>\n');
 								  res.write('<title>404 Not Found</title>\n');
 								  res.write('<h1>Not Found</h1>');
 								  res.write(
 								    '<p>The requested URL ' +
 								    escapeHtml(path) +
 								    ' was not found on this server.</p>'
 								  );
 								  res.end();
 								  util.puts('404 Not Found: ' + path);
 								};
 								StaticServlet.prototype.sendForbidden_ = function(req, res, path) {
 								  path = path.substring(1);
 								  res.writeHead(403, {
 								      'Content-Type': 'text/html'
 								  });
 								  res.write('<!doctype html>\n');
 								  res.write('<title>403 Forbidden</title>\n');
 								  res.write('<h1>Forbidden</h1>');
 								  res.write(
 								    '<p>You do not have permission to access ' +
 								    escapeHtml(path) + ' on this server.</p>'
 								  );
 								  res.end();
 								  util.puts('403 Forbidden: ' + path);
 								};
 								StaticServlet.prototype.sendRedirect_ = function(req, res, redirectUrl) {
 								  res.writeHead(301, {
 								      'Content-Type': 'text/html',
 								      'Location': redirectUrl
 								  });
 								  res.write('<!doctype html>\n');
 								  res.write('<title>301 Moved Permanently</title>\n');
 								  res.write('<h1>Moved Permanently</h1>');
 								  res.write(
 								    '<p>The document has moved <a href="' +
 								    redirectUrl +
 								    '">here</a>.</p>'
 								  );
 								  res.end();
 								  util.puts('301 Moved Permanently: ' + redirectUrl);
 								};
 								StaticServlet.prototype.sendFile_ = function(req, res, path) {
 								  var self = this;
 								  var file = fs.createReadStream(path);
 								  res.writeHead(200, {
 								    'Content-Type': StaticServlet.
 								      MimeMap[path.split('.').pop()] || 'text/plain'
 								  });
 								  if (req.method === 'HEAD') {
 								    res.end();
 								  } else {
 								    file.on('data', res.write.bind(res));
 								    file.on('close', function() {
 								      res.end();
 								    });
 								    file.on('error', function(error) {
 								      self.sendError_(req, res, error);
 								    });
 								  }
 								};
 								StaticServlet.prototype.sendDirectory_ = function(req, res, path) {
 								  var self = this;
 								  fs.readdir(path, function(err, files) {
 								    if (err)
 								      return self.sendError_(req, res, error);
 								    if (!files.length)
 								      return self.writeDirectoryIndex_(req, res, path, []);
 								    var remaining = files.length;
 								    files.forEach(function(fileName, index) {
 								      fs.stat(path + '/' + fileName, function(err, stat) {
 								        if (err)
 								          return self.sendError_(req, res, err);
 								        if (stat.isDirectory()) {
 								          files[index] = fileName + '/';
 								        }
 								        if (!(--remaining))
 								          return self.writeDirectoryIndex_(req, res, path, files);
 								      });
 								    });
 								  });
 								};
 								StaticServlet.prototype.writeDirectoryIndex_ = function(req, res, path, files) {
 								  path = path.substring(1);
 								  res.writeHead(200, {
 								    'Content-Type': 'text/html'
 								  });
 								  if (req.method === 'HEAD') {
 								    res.end();
 								    return;
 								  }
 								  res.write('<!doctype html>\n');
 								  res.write('<title>' + escapeHtml(path) + '</title>\n');
 								  res.write('<style>\n');
 								  res.write('  ol { list-style-type: none; font-size: 1.2em; }\n');
 								  res.write('</style>\n');
 								  res.write('<h1>Directory: ' + escapeHtml(path) + '</h1>');
 								  res.write('<ol>');
 								  files.forEach(function(fileName) {
 								    if (fileName.charAt(0) !== '.') {
 								      res.write('<li><a href="' +
 								        escapeHtml(fileName) + '">' +
 								        escapeHtml(fileName) + '</a></li>');
 								    }
 								  });
 								  res.write('</ol>');
 								  res.end();
 								};
-												Bug 1160359 - web-server: init: check config file, fix app root

* warn if local.conf.js doesn't exist and suggest the sample config
* set the web root relative to the server script such that it can be
  invoked from anywhere and keep the serving the same URLs

it seems that stat[Sync] is more likely to stay than exists[Sync] on path or fs
see http://stackoverflow.com/a/4482701/3339341

											
										
										
											2015-04-24 09:12:26 +03:00
+								function isFile(filename) {
 								  try {
 								    if (!fs.statSync(filename).isFile())
 								      throw("not a file");
 								  } catch (e) {
 								    return false;
 								  }
 								  return true;
 								}
 								// All the HTML files include the config file directly but none of them warns
 								// if it doesn't exist, so when starting the server is a good time to warn.
-												Bug 1165925 - web-server.js should serve index.html at the site root

											
										
										
											2015-05-18 18:38:56 +03:00
+								var confFile = path.join(APP_ROOT, "js", "config", "local.conf.js");
-												Bug 1160359 - web-server: init: check config file, fix app root

* warn if local.conf.js doesn't exist and suggest the sample config
* set the web root relative to the server script such that it can be
  invoked from anywhere and keep the serving the same URLs

it seems that stat[Sync] is more likely to stay than exists[Sync] on path or fs
see http://stackoverflow.com/a/4482701/3339341

											
										
										
											2015-04-24 09:12:26 +03:00
+								if (!isFile(confFile)) {
 								  console.log("Missing config file '" + confFile + "'.\n" +
 								              "Consider copying it from 'sample.local.conf.js' at the same directory.");
 								}
-												add angular webapp skeleton

											
										
										
											2013-07-11 21:52:04 +04:00
+								// Must be last,
 								main(process.argv);