reddit plugin configuration from file, not from options now. Scheduling, refactoring of sync mutex

plugins/reddit.js

@@ -7,7 +7,8 @@ const log = require('../services/log');
 const utils = require('../services/utils');
 const unescape = require('unescape');
 const attributes = require('../services/attributes');
-const options = require('../services/options');
+const sync_mutex = require('../services/sync_mutex');
+const config = require('../services/config');
 
 const REDDIT_ROOT = 'reddit_root';
 
@@ -106,7 +107,7 @@ async function getDateNoteIdForReddit(dateTimeStr, rootNoteId) {
     return redditDateNoteId;
 }
 
-async function importReddit(accountName, afterId = null) {
+async function importComments(accountName, afterId = null) {
     let rootNoteId = await sql.getFirstValue(`SELECT notes.note_id FROM notes JOIN attributes USING(note_id) 
               WHERE attributes.name = '${REDDIT_ROOT}' AND notes.is_deleted = 0`);
 
@@ -173,38 +174,47 @@ async function importReddit(accountName, afterId = null) {
     if (listing.data.after && importedComments > 0) {
         log.info("Reddit: Importing from next page of comments ...");
 
-        importedComments += await importReddit(accountName, listing.data.after);
+        importedComments += await importComments(accountName, listing.data.after);
     }
 
     return importedComments;
 }
 
-sql.dbReady.then(async () => {
+let redditAccounts = [];
-    const enabledOption = await options.getOptionOrNull("reddit_enabled");
-    const accountsOption = await options.getOptionOrNull("reddit_accounts");
 
-    if (!enabledOption) {
+async function runImport() {
-        await options.createOption("reddit_enabled", "false", true);
+    // technically mutex shouldn't be necessary but we want to avoid doing potentially expensive import
-        await options.createOption("reddit_accounts", "[]", true);
+    // concurrently with sync
-        return;
+    await sync_mutex.doExclusively(async () => {
-    }
-
-    if (enabledOption.opt_value !== "true") {
-        return;
-    }
-
-    if (!accountsOption) {
-        log.info("Reddit: No reddit accounts defined in option 'reddit_accounts'");
-    }
-
-    const redditAccounts = JSON.parse(accountsOption.opt_value);
         let importedComments = 0;
 
         for (const account of redditAccounts) {
             log.info("Reddit: Importing account " + account);
 
-        importedComments += await importReddit(account);
+            importedComments += await importComments(account);
         }
 
         log.info(`Reddit: Imported ${importedComments} comments.`);
+    });
+}
+
+sql.dbReady.then(async () => {
+    console.log(config);
+
+    if (!config['Reddit'] || !config['Reddit']['enabled'] !== true) {
+        return;
+    }
+
+    const redditAccountsStr = config['Reddit']['accounts'];
+
+    if (!redditAccountsStr) {
+        log.info("Reddit: No reddit accounts defined in option 'reddit_accounts'");
+    }
+
+    redditAccounts = redditAccountsStr.split(",").map(s => s.trim());
+
+    const pollingIntervalInSeconds = config['Reddit']['pollingIntervalInSeconds'] || 3600;
+
+    setInterval(runImport, pollingIntervalInSeconds * 1000);
+    setTimeout(runImport, 1000);
 });

services/backup.js

@@ -23,9 +23,8 @@ async function regularBackup() {
 
 async function backupNow() {
     // we don't want to backup DB in the middle of sync with potentially inconsistent DB state
-    const releaseMutex = await sync_mutex.acquire();
 
-    try {
+    await sync_mutex.doExclusively(async () => {
         const now = utils.nowDate();
 
         const backupFile = dataDir.BACKUP_DIR + "/" + "backup-" + utils.getDateTimeForFile() + ".db";
@@ -37,10 +36,7 @@ async function backupNow() {
         await sql.doInTransaction(async () => {
             await options.setOption('last_backup_date', now);
         });
-    }
+    });
-    finally {
-        releaseMutex();
-    }
 }
 
 async function cleanupOldBackups() {

services/consistency_checks.js

@@ -217,18 +217,14 @@ async function runAllChecks() {
 async function runChecks() {
     let errorList;
     let elapsedTimeMs;
-    const releaseMutex = await sync_mutex.acquire();
 
-    try {
+    await sync_mutex.doExclusively(async () => {
         const startTime = new Date();
 
         errorList = await runAllChecks();
 
         elapsedTimeMs = new Date().getTime() - startTime.getTime();
-    }
+    });
-    finally {
-        releaseMutex();
-    }
 
     if (errorList.length > 0) {
         log.info(`Consistency checks failed (took ${elapsedTimeMs}ms) with these errors: ` + JSON.stringify(errorList));

services/sync.js

@@ -20,9 +20,8 @@ let proxyToggle = true;
 let syncServerCertificate = null;
 
 async function sync() {
-    const releaseMutex = await sync_mutex.acquire();
-
     try {
+        await sync_mutex.doExclusively(async () => {
             if (!await sql.isDbUpToDate()) {
                 return {
                     success: false,
@@ -39,6 +38,7 @@ async function sync() {
             await pushSync(syncContext);
 
             await checkContentHash(syncContext);
+        });
 
         return {
             success: true
@@ -64,9 +64,6 @@ async function sync() {
             }
         }
     }
-    finally {
-        releaseMutex();
-    }
 }
 
 async function login() {

services/sync_mutex.js

@@ -4,5 +4,20 @@
  */
 
 const Mutex = require('async-mutex').Mutex;
+const instance = new Mutex();
 
-module.exports = new Mutex();
+async function doExclusively(func) {
+    const releaseMutex = await instance.acquire();
+
+    try {
+        await func();
+    }
+    finally {
+        releaseMutex();
+    }
+
+}
+
+module.exports = {
+    doExclusively
+};