The Big Renaming - etherpad is now an NPM module

src/node/hooks/express/apicalls.js

@@ -0,0 +1,58 @@
+var log4js = require('log4js');
+var apiLogger = log4js.getLogger("API");
+var formidable = require('formidable');
+var apiHandler = require('../../handler/APIHandler');
+
+//This is for making an api call, collecting all post information and passing it to the apiHandler
+exports.apiCaller = function(req, res, fields) {
+  res.header("Content-Type", "application/json; charset=utf-8");
+
+  apiLogger.info("REQUEST, " + req.params.func + ", " + JSON.stringify(fields));
+
+  //wrap the send function so we can log the response
+  res._send = res.send;
+  res.send = function (response) {
+    response = JSON.stringify(response);
+    apiLogger.info("RESPONSE, " + req.params.func + ", " + response);
+
+    //is this a jsonp call, if yes, add the function call
+    if(req.query.jsonp)
+      response = req.query.jsonp + "(" + response + ")";
+
+    res._send(response);
+  }
+
+  //call the api handler
+  apiHandler.handle(req.params.func, fields, req, res);
+}
+
+
+exports.expressCreateServer = function (hook_name, args, cb) {
+  //This is a api GET call, collect all post informations and pass it to the apiHandler
+  args.app.get('/api/1/:func', function (req, res) {
+    apiCaller(req, res, req.query)
+  });
+
+  //This is a api POST call, collect all post informations and pass it to the apiHandler
+  args.app.post('/api/1/:func', function(req, res) {
+    new formidable.IncomingForm().parse(req, function (err, fields, files) {
+      apiCaller(req, res, fields)
+    });
+  });
+
+  //The Etherpad client side sends information about how a disconnect happen
+  args.app.post('/ep/pad/connection-diagnostic-info', function(req, res) {
+    new formidable.IncomingForm().parse(req, function(err, fields, files) { 
+      console.log("DIAGNOSTIC-INFO: " + fields.diagnosticInfo);
+      res.end("OK");
+    });
+  });
+
+  //The Etherpad client side sends information about client side javscript errors
+  args.app.post('/jserror', function(req, res) {
+    new formidable.IncomingForm().parse(req, function(err, fields, files) { 
+      console.error("CLIENT SIDE JAVASCRIPT ERROR: " + fields.errorInfo);
+      res.end("OK");
+    });
+  });
+}

src/node/hooks/express/errorhandling.js

@@ -0,0 +1,52 @@
+var os = require("os");
+var db = require('../../db/DB');
+
+
+exports.onShutdown = false;
+exports.gracefulShutdown = function(err) {
+  if(err && err.stack) {
+    console.error(err.stack);
+  } else if(err) {
+    console.error(err);
+  }
+
+  //ensure there is only one graceful shutdown running
+  if(exports.onShutdown) return;
+  exports.onShutdown = true;
+
+  console.log("graceful shutdown...");
+
+  //stop the http server
+  exports.app.close();
+
+  //do the db shutdown
+  db.db.doShutdown(function() {
+    console.log("db sucessfully closed.");
+
+    process.exit(0);
+  });
+
+  setTimeout(function(){
+    process.exit(1);
+  }, 3000);
+}
+
+
+exports.expressCreateServer = function (hook_name, args, cb) {
+  exports.app = args.app;
+
+  args.app.error(function(err, req, res, next){
+    res.send(500);
+    console.error(err.stack ? err.stack : err.toString());
+    exports.gracefulShutdown();
+  });
+
+  //connect graceful shutdown with sigint and uncaughtexception
+  if(os.type().indexOf("Windows") == -1) {
+    //sigint is so far not working on windows
+    //https://github.com/joyent/node/issues/1553
+    process.on('SIGINT', exports.gracefulShutdown);
+  }
+
+  process.on('uncaughtException', exports.gracefulShutdown);
+}

src/node/hooks/express/importexport.js

@@ -0,0 +1,41 @@
+var hasPadAccess = require("../../padaccess");
+var settings = require('../../utils/Settings');
+var exportHandler = require('../../handler/ExportHandler');
+var importHandler = require('../../handler/ImportHandler');
+
+exports.expressCreateServer = function (hook_name, args, cb) {
+  args.app.get('/p/:pad/:rev?/export/:type', function(req, res, next) {
+    var types = ["pdf", "doc", "txt", "html", "odt", "dokuwiki"];
+    //send a 404 if we don't support this filetype
+    if (types.indexOf(req.params.type) == -1) {
+      next();
+      return;
+    }
+
+    //if abiword is disabled, and this is a format we only support with abiword, output a message
+    if (settings.abiword == null &&
+       ["odt", "pdf", "doc"].indexOf(req.params.type) !== -1) {
+      res.send("Abiword is not enabled at this Etherpad Lite instance. Set the path to Abiword in settings.json to enable this feature");
+      return;
+    }
+
+    res.header("Access-Control-Allow-Origin", "*");
+
+    hasPadAccess(req, res, function() {
+      exportHandler.doExport(req, res, req.params.pad, req.params.type);
+    });
+  });
+
+  //handle import requests
+  args.app.post('/p/:pad/import', function(req, res, next) {
+    //if abiword is disabled, skip handling this request
+    if(settings.abiword == null) {
+      next();
+      return; 
+    }
+
+    hasPadAccess(req, res, function() {
+      importHandler.doImport(req, res, req.params.pad);
+    });
+  });
+}

src/node/hooks/express/minified.js

@@ -0,0 +1,6 @@
+var minify = require('../../utils/Minify');
+
+exports.expressCreateServer = function (hook_name, args, cb) {
+  //serve minified files
+  args.app.get('/minified/:filename', minify.minifyJS);
+}

src/node/hooks/express/padreadonly.js

@@ -0,0 +1,65 @@
+var async = require('async');
+var ERR = require("async-stacktrace");
+var readOnlyManager = require("../../db/ReadOnlyManager");
+var hasPadAccess = require("../../padaccess");
+var exporthtml = require("../../utils/ExportHtml");
+
+exports.expressCreateServer = function (hook_name, args, cb) {
+  //serve read only pad
+  args.app.get('/ro/:id', function(req, res)
+  { 
+    var html;
+    var padId;
+    var pad;
+
+    async.series([
+      //translate the read only pad to a padId
+      function(callback)
+      {
+	readOnlyManager.getPadId(req.params.id, function(err, _padId)
+	{
+	  if(ERR(err, callback)) return;
+
+	  padId = _padId;
+
+	  //we need that to tell hasPadAcess about the pad  
+	  req.params.pad = padId; 
+
+	  callback();
+	});
+      },
+      //render the html document
+      function(callback)
+      {
+	//return if the there is no padId
+	if(padId == null)
+	{
+	  callback("notfound");
+	  return;
+	}
+
+	hasPadAccess(req, res, function()
+	{
+	  //render the html document
+	  exporthtml.getPadHTMLDocument(padId, null, false, function(err, _html)
+	  {
+	    if(ERR(err, callback)) return;
+	    html = _html;
+	    callback();
+	  });
+	});
+      }
+    ], function(err)
+    {
+      //throw any unexpected error
+      if(err && err != "notfound")
+	ERR(err);
+
+      if(err == "notfound")
+	res.send('404 - Not Found', 404);
+      else
+	res.send(html);
+    });
+  });
+
+}

src/node/hooks/express/padurlsanitize.js

@@ -0,0 +1,29 @@
+var padManager = require('../../db/PadManager');
+
+exports.expressCreateServer = function (hook_name, args, cb) {
+  //redirects browser to the pad's sanitized url if needed. otherwise, renders the html
+  args.app.param('pad', function (req, res, next, padId) {
+    //ensure the padname is valid and the url doesn't end with a /
+    if(!padManager.isValidPadId(padId) || /\/$/.test(req.url))
+    {
+      res.send('Such a padname is forbidden', 404);
+    }
+    else
+    {
+      padManager.sanitizePadId(padId, function(sanitizedPadId) {
+	//the pad id was sanitized, so we redirect to the sanitized version
+	if(sanitizedPadId != padId)
+	{
+	  var real_path = req.path.replace(/^\/p\/[^\/]+/, '/p/' + sanitizedPadId);
+	  res.header('Location', real_path);
+	  res.send('You should be redirected to <a href="' + real_path + '">' + real_path + '</a>', 302);
+	}
+	//the pad id was fine, so just render it
+	else
+	{
+	  next();
+	}
+      });
+    }
+  });
+}

src/node/hooks/express/socketio.js

@@ -0,0 +1,49 @@
+var log4js = require('log4js');
+var socketio = require('socket.io');
+var settings = require('../../utils/Settings');
+var socketIORouter = require("../../handler/SocketIORouter");
+var hooks = require("../../pluginfw/hooks");
+
+var padMessageHandler = require("../../handler/PadMessageHandler");
+var timesliderMessageHandler = require("../../handler/TimesliderMessageHandler");
+
+
+exports.expressCreateServer = function (hook_name, args, cb) {
+  //init socket.io and redirect all requests to the MessageHandler
+  var io = socketio.listen(args.app);
+
+  //this is only a workaround to ensure it works with all browers behind a proxy
+  //we should remove this when the new socket.io version is more stable
+  io.set('transports', ['xhr-polling']);
+
+  var socketIOLogger = log4js.getLogger("socket.io");
+  io.set('logger', {
+    debug: function (str)
+    {
+      socketIOLogger.debug.apply(socketIOLogger, arguments);
+    }, 
+    info: function (str)
+    {
+      socketIOLogger.info.apply(socketIOLogger, arguments);
+    },
+    warn: function (str)
+    {
+      socketIOLogger.warn.apply(socketIOLogger, arguments);
+    },
+    error: function (str)
+    {
+      socketIOLogger.error.apply(socketIOLogger, arguments);
+    },
+  });
+
+  //minify socket.io javascript
+  if(settings.minify)
+    io.enable('browser client minification');
+
+  //Initalize the Socket.IO Router
+  socketIORouter.setSocketIO(io);
+  socketIORouter.addComponent("pad", padMessageHandler);
+  socketIORouter.addComponent("timeslider", timesliderMessageHandler);
+
+  hooks.callAll("socketio", {"app": args.app, "io": io});
+}

src/node/hooks/express/specialpages.js

@@ -0,0 +1,48 @@
+var path = require('path');
+
+exports.expressCreateServer = function (hook_name, args, cb) {
+
+  //serve index.html under /
+  args.app.get('/', function(req, res)
+  {
+    var filePath = path.normalize(__dirname + "/../../../static/index.html");
+    res.sendfile(filePath, { maxAge: exports.maxAge });
+  });
+
+  //serve robots.txt
+  args.app.get('/robots.txt', function(req, res)
+  {
+    var filePath = path.normalize(__dirname + "/../../../static/robots.txt");
+    res.sendfile(filePath, { maxAge: exports.maxAge });
+  });
+
+  //serve favicon.ico
+  args.app.get('/favicon.ico', function(req, res)
+  {
+    var filePath = path.normalize(__dirname + "/../../../static/custom/favicon.ico");
+    res.sendfile(filePath, { maxAge: exports.maxAge }, function(err)
+    {
+      //there is no custom favicon, send the default favicon
+      if(err)
+      {
+	filePath = path.normalize(__dirname + "/../../../static/favicon.ico");
+	res.sendfile(filePath, { maxAge: exports.maxAge });
+      }
+    });
+  });
+
+  //serve pad.html under /p
+  args.app.get('/p/:pad', function(req, res, next)
+  {    
+    var filePath = path.normalize(__dirname + "/../../../static/pad.html");
+    res.sendfile(filePath, { maxAge: exports.maxAge });
+  });
+
+  //serve timeslider.html under /p/$padname/timeslider
+  args.app.get('/p/:pad/timeslider', function(req, res, next)
+  {
+    var filePath = path.normalize(__dirname + "/../../../static/timeslider.html");
+    res.sendfile(filePath, { maxAge: exports.maxAge });
+  });
+
+}

src/node/hooks/express/static.js

@@ -0,0 +1,32 @@
+var path = require('path');
+var minify = require('../../utils/Minify');
+var plugins = require("../../pluginfw/plugins");
+
+exports.expressCreateServer = function (hook_name, args, cb) {
+  //serve static files
+  args.app.get('/static/js/require-kernel.js', function (req, res, next) {
+    res.header("Content-Type","application/javascript; charset: utf-8");
+    res.write(minify.requireDefinition());
+    res.end();
+  });
+
+  /* Handle paths like "/static/js/plugins/pluginomatic_myplugin/test.js"
+     by rewriting it to ROOT_PATH_OF_MYPLUGIN/static/js/test.js,
+     commonly ETHERPAD_ROOT/node_modules/pluginomatic_myplugin/static/js/test.js
+  */
+  args.app.get(/^\/static\/([^\/]+)\/plugins\/([^\/]+)\/(.*)/, function(req, res) {
+    var type_dir = req.params[0].replace(/\.\./g, '').split("?")[0];
+    var plugin_name = req.params[1];
+    var url = req.params[2].replace(/\.\./g, '').split("?")[0];
+
+    var filePath = path.normalize(path.join(plugins.plugins[plugin_name].package.path, "static", type_dir, url));
+    res.sendfile(filePath, { maxAge: exports.maxAge });
+  });
+
+  // Handle normal static files
+  args.app.get('/static/*', function(req, res) { 
+    var filePath = path.normalize(__dirname + "/../../.." +
+				  req.url.replace(/\.\./g, '').split("?")[0]);
+    res.sendfile(filePath, { maxAge: exports.maxAge });
+  });
+}

src/node/hooks/express/webaccess.js

@@ -0,0 +1,36 @@
+var express = require('express');
+var log4js = require('log4js');
+var httpLogger = log4js.getLogger("http");
+var settings = require('../../utils/Settings');
+
+
+//checks for basic http auth
+exports.basicAuth = function (req, res, next) {
+  if (req.headers.authorization && req.headers.authorization.search('Basic ') === 0) {
+    // fetch login and password
+    if (new Buffer(req.headers.authorization.split(' ')[1], 'base64').toString() == settings.httpAuth) {
+      next();
+      return;
+    }
+  }
+
+  res.header('WWW-Authenticate', 'Basic realm="Protected Area"');
+  if (req.headers.authorization) {
+    setTimeout(function () {
+      res.send('Authentication required', 401);
+    }, 1000);
+  } else {
+    res.send('Authentication required', 401);
+  }
+}
+
+exports.expressConfigure = function (hook_name, args, cb) {
+  // Activate http basic auth if it has been defined in settings.json
+  if(settings.httpAuth != null) args.app.use(exports.basicAuth);
+
+  // If the log level specified in the config file is WARN or ERROR the application server never starts listening to requests as reported in issue #158.
+  // Not installing the log4js connect logger when the log level has a higher severity than INFO since it would not log at that level anyway.
+  if (!(settings.loglevel === "WARN" || settings.loglevel == "ERROR"))
+    args.app.use(log4js.connectLogger(httpLogger, { level: log4js.levels.INFO, format: ':status, :method :url'}));
+  args.app.use(express.cookieParser());
+}