updates, should all work

bin/letsencrypt.js

@@ -81,11 +81,11 @@ cli.main(function(_, options) {
     var handlers;
     
     if (args.standalone) {
-      handlers = require('../lib/standalone');
+      handlers = require('../lib/standalone').create();
       handlers.startServers(args.http01Ports || [80], args.tlsSni01Port || [443, 5001]);
     }
     else if (args.webrootPath) {
-      handlers = require('../lib/webroot');
+      handlers = require('../lib/webroot').create(args);
     }
 
     LE.create({}, handlers).register(args, function (err, results) {

lib/standalone.js

@@ -1,62 +1,69 @@
 'use strict';
 
-var handlers = module.exports = {
+var handlers = module.exports.create = function () {
-  //
+  return {
-  // set,get,remove challenges
+    //
-  //
+    // set,get,remove challenges
-  _challenges: {}
+    //
-, setChallenge: function (args, key, value, cb) {
+    // Note: this is fine for a one-off CLI tool
-    handlers._challenges[key] = value;
+    // but a webserver using node-cluster or multiple
-    cb(null);
+    // servers should use a database of some sort
-  }
+    _challenges: {}
-, getChallenge: function (args, key, cb) {
+  , setChallenge: function (args, key, value, cb) {
-    cb(null, handlers._challenges[key]);
+      handlers._challenges[key] = value;
-  }
+      cb(null);
-, removeChallenge: function (args, key, cb) {
+    }
-    delete handlers._challenges[key];
+  , getChallenge: function (args, key, cb) {
-    cb(null);
+      // TODO keep in mind that, generally get args are just args.domains
-  }
+      // and it is disconnected from the flow of setChallenge and removeChallenge
-
+      cb(null, handlers._challenges[key]);
-, _servers: []
+    }
-, httpResponder: function (req, res) {
+  , removeChallenge: function (args, key, cb) {
-    var acmeChallengePrefix = '/.well-known/acme-challenge/';
+      delete handlers._challenges[key];
-
+      cb(null);
-    if (0 !== req.url.indexOf(acmeChallengePrefix)) {
-      res.end('Hello World!');
-      return;
     }
 
-    var key = req.url.slice(acmeChallengePrefix.length);
+  , _servers: []
+  , httpResponder: function (req, res) {
+      var acmeChallengePrefix = '/.well-known/acme-challenge/';
 
-    handlers.getChallenge(req.headers.host, key, function (err, val) {
+      if (0 !== req.url.indexOf(acmeChallengePrefix)) {
-      res.end(val || '_');
+        res.end('Hello World!');
-    });
+        return;
-  }
+      }
-, startServers: function (plainPorts, tlsPorts) {
-    var httpsOptions = require('localhost.daplie.com-certificates');
-    var https = require('https');
-    var http = require('http');
 
-    // tls-sni-01-port
+      var key = req.url.slice(acmeChallengePrefix.length);
-    if (handlers._servers.length) {
+
-      return;
+      handlers.getChallenge(req.headers.host, key, function (err, val) {
+        res.end(val || '_');
+      });
     }
+  , startServers: function (plainPorts, tlsPorts) {
+      var httpsOptions = require('localhost.daplie.com-certificates');
+      var https = require('https');
+      var http = require('http');
 
-    plainPorts.forEach(function (port) {
+      // tls-sni-01-port
-      http.createServer(handlers.httpResponder).listen(port, function () {
+      if (handlers._servers.length) {
-        console.info('Listening http on', this.address());
+        return;
+      }
+
+      plainPorts.forEach(function (port) {
+        http.createServer(handlers.httpResponder).listen(port, function () {
+          console.info('Listening http on', this.address());
+        });
       });
-    });
+      tlsPorts.forEach(function (port) {
-    tlsPorts.forEach(function (port) {
+        https.createServer(httpsOptions, handlers.httpResponder).listen(port, function () {
-      https.createServer(httpsOptions, handlers.httpResponder).listen(port, function () {
+          console.info('Listening https on', this.address());
-        console.info('Listening https on', this.address());
+        });
       });
-    });
+    }
-  }
+  , closeServers: function () {
-, closeServers: function () {
+      handlers._servers.forEach(function (server) {
-    handlers._servers.forEach(function (server) {
+        server.close();
-      server.close();
+      });
-    });
+      handlers._servers = [];
-    handlers._servers = [];
+    }
-  }
+  };
 };

lib/webroot.js

@@ -0,0 +1,51 @@
+'use strict';
+
+var handlers = module.exports.create = function (defaults) {
+  var fs = require('fs');
+  var path = require('path');
+  var mkdirp = require('mkdirp');
+
+  return {
+    //
+    // set,get,remove challenges
+    //
+    _challenges: {}
+  , setChallenge: function (args, key, value, cb) {
+      mkdirp(defaults.webrootPath, function (err) {
+        if (err) {
+          console.error("Could not create --webroot-path '" + defaults.webrootPath + "':", err.code);
+          console.error("Try checking the permissions, maybe?");
+          cb(err);
+          return;
+        }
+
+        var keyfile = path.join(defaults.webrootPath, key);
+
+        fs.writeFile(keyfile, value, 'utf8', function (err) {
+          if (err) {
+            console.error("Could not write '" + keyfile + "':", err.code);
+            cb(err);
+            return;
+          }
+
+          cb(null);
+        });
+      });
+    }
+  // handled as file read by web server
+  // , getChallenge: function (args, key, cb) {}
+  , removeChallenge: function (args, key, cb) {
+      var keyfile = path.join(defaults.webrootPath, key);
+
+      fs.unlink(keyfile, function (err) {
+        if (err) {
+          console.error("Could not unlink '" + keyfile + "':", err.code);
+          cb(err);
+          return;
+        }
+
+        cb(null);
+      });
+    }
+  };
+};