Draft: Initial ActivityPub / Mastodon Support

core/config_default.js

@@ -160,6 +160,7 @@ module.exports = () => {
             mods: paths.join(__dirname, './../mods/'),
             loginServers: paths.join(__dirname, './servers/login/'),
             contentServers: paths.join(__dirname, './servers/content/'),
+            webHandlers: paths.join(__dirname, './servers/content/web_handlers'),
             chatServers: paths.join(__dirname, './servers/chat/'),
 
             scannerTossers: paths.join(__dirname, './scanner_tossers/'),

core/listening_server.js

@@ -6,6 +6,7 @@ const logger = require('./logger.js');
 
 //  deps
 const async = require('async');
+const isFunction = require('lodash/isFunction');
 
 const listeningServers = {}; //  packageName -> info
 
@@ -36,24 +37,47 @@ function startListening(cb) {
                 (module, nextModule) => {
                     const moduleInst = new module.getModule();
                     try {
-                        moduleInst.createServer(err => {
-                            if (err) {
-                                return nextModule(err);
-                            }
+                        async.series(
+                            [
+                                callback => {
+                                    return moduleInst.createServer(callback);
+                                },
+                                callback => {
+                                    listeningServers[module.moduleInfo.packageName] = {
+                                        instance: moduleInst,
+                                        info: module.moduleInfo,
+                                    };
 
-                            moduleInst.listen(err => {
+                                    if (!isFunction(moduleInst.beforeListen)) {
+                                        return callback(null);
+                                    }
+                                    moduleInst.beforeListen(err => {
+                                        return callback(err);
+                                    });
+                                },
+                                callback => {
+                                    return moduleInst.listen(callback);
+                                },
+                                callback => {
+                                    if (!isFunction(moduleInst.afterListen)) {
+                                        return callback(null);
+                                    }
+                                    moduleInst.afterListen(err => {
+                                        return callback(err);
+                                    });
+                                },
+                            ],
+                            err => {
                                 if (err) {
+                                    delete listeningServers[
+                                        module.moduleInfo.packageName
+                                    ];
                                     return nextModule(err);
                                 }
 
-                                listeningServers[module.moduleInfo.packageName] = {
-                                    instance: moduleInst,
-                                    info: module.moduleInfo,
-                                };
-
                                 return nextModule(null);
-                            });
-                        });
+                            }
+                        );
                     } catch (e) {
                         logger.log.error(e, 'Exception caught creating server!');
                         return nextModule(e);

core/servers/content/web.js

@@ -17,6 +17,8 @@ const mimeTypes = require('mime-types');
 const forEachSeries = require('async/forEachSeries');
 const findSeries = require('async/findSeries');
 
+const { loadModulesForCategory } = require('../../module_util');
+
 const ModuleInfo = (exports.moduleInfo = {
     name: 'Web',
     desc: 'Web Server',
@@ -138,6 +140,30 @@ exports.getModule = class WebServerModule extends ServerModule {
         return cb(null);
     }
 
+    beforeListen(cb) {
+        if (!this.isEnabled()) {
+            return cb(null);
+        }
+
+        loadModulesForCategory(
+            'webHandlers',
+            (module, nextModule) => {
+                const moduleInst = new module.getModule();
+                try {
+                    moduleInst.init(err => {
+                        return nextModule(err);
+                    });
+                } catch (e) {
+                    logger.log.error(e, 'Exception caught web handler!');
+                    return nextModule(e);
+                }
+            },
+            err => {
+                return cb(err);
+            }
+        );
+    }
+
     listen(cb) {
         const config = Config();
         forEachSeries(

core/servers/content/web_handlers/webfinger.js

@@ -0,0 +1,135 @@
+const { ServerModule } = require('../../../server_module');
+const Config = require('../../../config').get;
+const { Errors } = require('../../../enig_error');
+
+const WebServerPackageName = require('../web').moduleInfo.packageName;
+
+const _ = require('lodash');
+const User = require('../../../user');
+const { result } = require('lodash');
+const Log = require('../../../logger').log;
+
+exports.moduleInfo = {
+    name: 'WebFinger',
+    desc: 'A simple WebFinger Handler',
+    author: 'NuSkooler',
+    packageName: 'codes.l33t.enigma.web.handler.finger',
+};
+
+exports.getModule = class WebFingerServerModule extends ServerModule {
+    constructor() {
+        super();
+    }
+
+    init(cb) {
+        if (!_.get(Config(), 'contentServers.web.handlers.webFinger.enabled')) {
+            return cb(null);
+        }
+
+        const { getServer } = require('../../../listening_server');
+
+        // we rely on the web server
+        this.webServer = getServer(WebServerPackageName);
+        if (!this.webServer || !this.webServer.instance.isEnabled()) {
+            return cb(Errors.UnexpectedState('Cannot access web server!'));
+        }
+
+        this.webServer.instance.addRoute({
+            method: 'GET',
+            path: /^\/\.well-known\/webfinger\/?\?/,
+            handler: this._webFingerRequestHandler.bind(this),
+        });
+
+        return cb(null);
+    }
+
+    _webFingerRequestHandler(req, resp) {
+        const url = new URL(req.url, `https://${req.headers.host}`);
+
+        const resource = url.searchParams.get('resource');
+        if (!resource) {
+            return this.webServer.instance.respondWithError(
+                resp,
+                400,
+                '"resource" is required',
+                'Missing "resource"'
+            );
+        }
+
+        this._getUser(resource, resp, (err, user, accountName) => {
+            if (err) {
+                // |resp| already written to
+                return Log.warn({ error: err.message }, `WebFinger failed: ${req.url}`);
+            }
+
+            const body = JSON.stringify({
+                subject: `acct:${accountName}`,
+                links: [this._profilePageLink(user)],
+            });
+
+            const headers = {
+                'Content-Type': 'application/jrd+json',
+                'Content-Length': body.length,
+            };
+
+            resp.writeHead(200, headers);
+            return resp.end(body);
+        });
+    }
+
+    _profilePageLink(user) {
+        const href = this.webServer.instance.buildUrl(`/wf/@${user.username}`);
+        return {
+            rel: 'http://webfinger.net/rel/profile-page',
+            type: 'text/plain',
+            href,
+        };
+    }
+
+    _getUser(resource, resp, cb) {
+        // we only handle "acct:NAME" URIs
+
+        const notFound = () => {
+            this.webServer.instance.respondWithError(
+                resp,
+                404,
+                'Resource not found',
+                'Resource Not Found'
+            );
+        };
+
+        const acctIndex = resource.indexOf('acct:', 0);
+        if (0 != acctIndex) {
+            notFound();
+            return cb(Errors.DoesNotExist('"acct:" missing'));
+        }
+
+        const accountName = resource.substring(acctIndex + 5);
+        const domain = _.get(Config(), 'contentServers.web.domain', 'localhost');
+        if (!accountName.endsWith(`@${domain}`)) {
+            notFound();
+            return cb(Errors.Invalid(`Invalid "acct" value: ${accountName}`));
+        }
+
+        const searchQuery = accountName.substring(
+            0,
+            accountName.length - (domain.length + 1)
+        );
+
+        User.getUserIdAndName(searchQuery, (err, userId) => {
+            if (err) {
+                notFound();
+                return cb(err);
+            }
+
+            User.getUser(userId, (err, user) => {
+                if (err) {
+                    notFound();
+                    return cb(err);
+                }
+
+                return cb(null, user, accountName);
+            });
+        });
+    }
+};