Implementing logs, stubbing xmlrpc

Author: andrewshell

.env-sample

@@ -1,2 +1,3 @@
 DOMAIN=localhost
 PORT=5337
+MONGODB_URI=mongodb://localhost:27017/rsscloud

README.md

@@ -16,15 +16,15 @@ npm start
 
 ### POST /pleaseNotify
 
-Posting to /pleaseNotify is your way of alerting the server that you want to receive notifications when one or more resources are updated. 
+Posting to /pleaseNotify is your way of alerting the server that you want to receive notifications when one or more resources are updated.
 
 The POST parameters are:
 
 1. domain -- optional, if omitted the requesting IP address is used
 2. port
 3. path
-4. registerProcedure -- required, but isn't used in this server as it only applies to xml-rpc or soap
-5. protocol -- the spec allows for http-post, xml-rpc or soap but this server only supports http-post
+4. registerProcedure -- required, but isn't used in this server as it only applies to xml-rpc or soap.
+5. protocol -- the spec allows for http-post, xml-rpc or soap but this server only supports http-post. This server also supports https-post which is identical to http-post except it notifies using https as the scheme instead of http.
 6. url1, url2, ..., urlN this is the resource you're requesting to be notified about.  In the case of an RSS feed you would specify the URL of the RSS feed.
 
 When you POST the server first checks if the urls you specifed are returning an [HTTP 2xx status code](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.2) then it attempts to notify the subscriber of an update to make sure it works.  This is done in one of two ways.
@@ -52,7 +52,7 @@ Examples:
 
 ### POST /ping
 
-Posting to /ping is your way of alerting the server that a resource has been updated. 
+Posting to /ping is your way of alerting the server that a resource has been updated.
 
 The POST parameters are:
 

app.js

@@ -11,7 +11,6 @@
         moment = require('moment'),
         mongodb = require('./services/mongodb'),
         morgan = require('morgan'),
-        Promise = require('bluebird'),
         removeExpiredSubscriptions = require('./services/remove-expired-subscriptions');
 
     let app,
@@ -60,7 +59,7 @@
     app.use(require('./controllers'));
 
     // Start server
-    mongodb.connect(config.mongodbUri)
+    mongodb.connect('rsscloud', config.mongodbUri)
         .then(() => {
             server = app.listen(config.port, function () {
                 app.locals.host = config.domain;

bin/import-data.js

@@ -3,7 +3,7 @@ const config = require('../config'),
     mongodb = require('../services/mongodb');
 
 async function doImport() {
-    const db = await mongodb.connect(config.mongodbUri);
+    const db = await mongodb.connect('rsscloud', config.mongodbUri);
 
     if (fs.existsSync('./data/data.json')) {
         const data = JSON.parse(fs.readFileSync('./data/data.json', 'utf8'));
@@ -22,19 +22,27 @@ async function doImport() {
 
         await db.collection('subscriptions').bulkWrite(
             Object.keys(data.subscriptions).map(id => {
+                const subscriptions = {
+                    _id: id,
+                    pleaseNotify: Object.keys(data.subscriptions[id]).map(sid => {
+                        const subscription = data.subscriptions[id][sid];
+                        subscription.url = sid;
+                        return subscription;
+                    })
+                }
                 return {
                     replaceOne: {
                         filter: { _id: id },
-                        replacement: data.subscriptions[id],
+                        replacement: subscriptions,
                         upsert: true
                     }
                 };
             })
         );
 
-        await mongodb.close();
+        await mongodb.close('rsscloud');
     } else {
-        await mongodb.close();
+        await mongodb.close('rsscloud');
 
         throw new Error('Cannot find ./data/data.json');
     }

controllers/docs.js

@@ -0,0 +1,24 @@
+(function () {
+    "use strict";
+
+    const express = require('express'),
+        router = new express.Router(),
+        md = require('markdown-it')(),
+        fs = require('fs');
+
+    router.get('/', function (req, res) {
+        switch (req.accepts('html')) {
+        case 'html':
+            const vals = {
+                htmltext: md.render(fs.readFileSync('README.md', { encoding: 'utf8' }))
+            };
+            res.render('docs', vals);
+            break;
+        default:
+            res.status(406).send('Not Acceptable');
+            break;
+        }
+    });
+
+    module.exports = router;
+}());

controllers/index.js

@@ -5,10 +5,13 @@
         router = new express.Router();
 
     router.use('/', require('./home'));
+    router.use('/docs', require('./docs'));
     router.use('/pleaseNotify', require('./please-notify'));
+    router.use('/pleaseNotifyForm', require('./please-notify-form'));
     router.use('/ping', require('./ping'));
     router.use('/pingForm', require('./ping-form'));
-    // router.use('/viewLog', require('./view-log'));
+    router.use('/viewLog', require('./view-log'));
+    router.use('/RPC2', require('./rpc2'));
 
     module.exports = router;
 }());

controllers/please-notify-form.js

@@ -0,0 +1,19 @@
+(function () {
+    "use strict";
+
+    const express = require('express'),
+        router = new express.Router();
+
+    router.get('/', function (req, res) {
+        switch (req.accepts('html')) {
+        case 'html':
+            res.render('please-notify-form');
+            break;
+        default:
+            res.status(406).send('Not Acceptable');
+            break;
+        }
+    });
+
+    module.exports = router;
+}());

controllers/rpc2.js

@@ -0,0 +1,28 @@
+(function () {
+    "use strict";
+
+    const express = require('express'),
+        parseRpcParams = require('../services/parse-rpc-params'),
+        router = new express.Router(),
+        rpcReturnSuccess = require('../services/rpc-return-success');
+
+    function processResponse(req, res, result) {
+        switch (req.accepts('xml')) {
+        case 'xml':
+            res.set('Content-Type', 'text/xml');
+            res.send(rpcReturnSuccess());
+            break;
+        default:
+            res.status(406).send('Not Acceptable');
+            break;
+        }
+    }
+
+    router.post('/', function (req, res) {
+        const params = parseRpcParams(req);
+        console.dir(params);
+        processResponse(req, res, params);
+    });
+
+    module.exports = router;
+}());

controllers/view-log.js

@@ -1,26 +1,34 @@
 (function () {
     "use strict";
 
-    var async = require('async'),
-        data = require('../services/data'),
-        errorResult = require('../services/error-result'),
+    const errorResult = require('../services/error-result'),
         express = require('express'),
         logEmitter = require('../services/log-emitter'),
+        mongodb = require('../services/mongodb'),
         router = new express.Router();
 
-    function fetchVals(db, callback) {
-        var vals = {
+    async function fetchVals(db, callback) {
+        const vals = {
             'eventlog': []
         };
 
-        db.serialize(() => {
-            db.each("SELECT * FROM log_events ORDER BY time DESC LIMIT 1000", (err, row) => {
-                row.headers = JSON.parse(row.headers);
-                vals.eventlog.push(row);
-            }, () => {
-                callback(null, vals);
-            });
+        const res = await mongodb.get('rsscloud')
+            .collection('events')
+            .find()
+            .sort({ time: -1 })
+            .limit(1000)
+            .toArray();
+
+        vals.eventlog = res.map(item => {
+            item.id = item._id.toHexString();
+            delete item._id;
+
+            item.headers = JSON.parse(item.headers);
+
+            return item;
         });
+
+        return vals;
     }
 
     function processResponse(req, res, vals) {
@@ -39,23 +47,14 @@
     }
 
     function handleError(req, res, errorMessage) {
-        processResponse(req, res, errorResult(errorMessage));
+        console.error(err);
+        processResponse(req, res, errorResult(err.message));
     }
 
     router.get('/', function (req, res) {
-        async.waterfall([
-            (callback) => {
-                data.getDb(callback);
-            },
-            (db, callback) => {
-                fetchVals(db, callback);
-            },
-            (vals) => {
-                processResponse(req, res, vals);
-            }
-        ], (errorMessage) => {
-            handleError(req, res, errorMessage);
-        });
+        fetchVals()
+            .then(vals => processResponse(req, res, vals))
+            .catch(err => handleError(req, res, err));
     });
 
     router.ws('/', (ws, req) => {