ldn-inbox-server 1.7.1 → 1.8.0

package/.env-example

@@ -4,12 +4,13 @@ LDN_SERVER_PORT=8000
 LDN_SERVER_INBOX_GLOB="^.*\.jsonld$"
 LDN_SERVER_BASEURL=http://localhost:8000
 LDN_SERVER_INBOX_BATH_SIZE=5
+LDN_SERVER_LOCKDIR=.lockdir
 LDN_SERVER_INBOX_URL=inbox/
 LDN_SERVER_INBOX_PATH=./inbox
 LDN_SERVER_ERROR_PATH=./error
 LDN_SERVER_OUTBOX_PATH=./outbox
 LDN_SERVER_PUBLIC_PATH=./public
-LDN_SERVER_JSON_SCHEMA=./config/notification_schema.json
+#LDN_SERVER_JSON_SCHEMA=./config/notification_schema.json
 LDN_SERVER_INBOX_CONFIG=./config/inbox_config.json
 LDN_SERVER_OUTBOX_CONFIG=./config/outbox_config.json
-LDN_SERVER_HAS_PUBLIC_INBOX=0
+LDN_SERVER_HAS_PUBLIC_INBOX=1

package/README.md

@@ -1,6 +1,6 @@
 # ldn-inbox-server
 
-An experimental LDN inbox server for [Event Notification](https://www.eventnotifications.net) messages.
+An experimental [LDN](https://www.w3.org/TR/ldn/) inbox server for [Event Notification](https://www.eventnotifications.net) messages.
 
 ## Install
 
@@ -16,8 +16,6 @@ Create required directories
 mkdir config inbox public
 ```
 
-Copy an example JSON Schema as `config/notification_schema.json` from this project.
-
 Start the server:
 
 ```
@@ -57,6 +55,7 @@ npx ldn-inbox-server handler @outbox -hn ./handler/send_notification_handler.js
 - `LDN_SERVER_INBOX_GLOB` : glob of files to process in inbox directory
 - `LDN_SERVER_HAS_PUBLIC_INBOX` : if true, then public read access is allowed on the inbox
 - `LDN_SERVER_HAS_WRITABLE_INBOX` : if true, then public write access is allowed on the inbox
+- `LDN_SERVER_LOCKDIR` : directory to store optional lock files for handler
   
 ## Multiple inboxes
 

package/bin/ldn-inbox-server.js

@@ -18,7 +18,7 @@ const PUBLIC_PATH = process.env.LDN_SERVER_PUBLIC_PATH ?? './public';
 const INBOX_PATH = process.env.LDN_SERVER_INBOX_PATH ?? './inbox';
 const ERROR_PATH = process.env.LDN_SERVER_ERROR_PATH ?? './error';
 const OUTBOX_PATH = process.env.LDN_SERVER_OUTBOX_PATH ?? './outbox';
-const JSON_SCHEMA_PATH = process.env.LDN_SERVER_JSON_SCHEMA ?? './config/notification_schema.json';
+const JSON_SCHEMA_PATH = process.env.LDN_SERVER_JSON_SCHEMA; 
 const INBOX_CONFIG = process.env.LDN_SERVER_INBOX_CONFIG;
 const OUTBOX_CONFIG = process.env.LDN_SERVER_OUTBOX_CONFIG;
 const HAS_PUBLIC = process.env.LDN_SERVER_HAS_PUBLIC_INBOX ?? 0;

package/config/inbox_config.json

@@ -27,6 +27,7 @@
                  },
                  {
                     "id": "@handler/notification_handler/offer_memento.js",
+                    "$sequential": true,
                     "actor": {
                         "id": "http://localhost:8000/profile/card#me" ,
                         "inbox": "http://localhost:8000/inbox/" ,

package/handler/notification_handler/multi.js

@@ -1,5 +1,9 @@
 const { dynamic_handler , parseConfig , parseAsJSON } = require('../../lib/util.js');
 const logger = require('../../lib/util.js').getLogger();
+const lockfile = require('proper-lockfile');
+const fs = require('fs');
+const fsPath = require('path');
+const md5 = require('md5');
 
 /**
  * Demonstration notification handler that start multiple notification handlers.
@@ -8,20 +12,21 @@ const logger = require('../../lib/util.js').getLogger();
  * which is an array of arrays. The outer array defines independent 'workflows' that
  * need to run on an notifiction message. The inner array defines the steps: a
  * sequence of handlers that need to success.
+ * 
+ * Optionally a configuration for a handler can contain the property `$sequential` set
+ * to true to force the sequential execution of this handler.
  */
-async function handle({path,options}) {
+async function handle({path,options,_, notification}) {
     let success = false;
 
-    const config = parseConfig(options['config']);
+    const mainConfig = parseConfig(options['config']);
 
-    if (! config) {
+    if (! mainConfig) {
         logger.error('no configuration found for multi_notification_handler');
         return { path, options, success: false };
     }
 
-    const notification = parseAsJSON(path);
-
-    const handlers = config['notification_handler']?.['multi']?.['handlers'];
+    const handlers = mainConfig['notification_handler']?.['multi']?.['handlers'];
 
     if (! handlers) {
         logger.error('no notification_handler.multi.handlers key in configuration file');
@@ -61,7 +66,9 @@ async function handle({path,options}) {
                     throw new Error(`failed to load ${step}`);
                 }
 
-                const result = await handler({path,options,config,notification});
+                const result = await maybeLock(step,config, async() => {
+                    return await handler({path,options,config,notification});
+                });
             
                 if (result['break']) {
                     logger.info(`workflow[${i}] : breaks ${step} with ${result['success']}`);
@@ -130,6 +137,40 @@ async function handle({path,options}) {
     logger.info(`finished multi handler`);
 
     return { path, options, success: success };
-}   
+}
+
+async function maybeLock(step,config,callback) {
+    if (config['$sequential']) {
+        const lockDir = process.env.LDN_SERVER_LOCKDIR || '.lockdir';
+
+        if (! fs.existsSync(lockDir)) {
+            logger.debug(`creating lock dir ${lockDir}`);
+            fs.mkdirSync(lockDir);
+        }
+
+        const lockFile = fsPath.join(lockDir,md5(step));
+
+        if (! fs.existsSync(lockFile)) {
+            logger.debug(`creating lock file ${lockFile}`);
+            fs.writeFileSync(lockFile,'');
+        }
+        
+        logger.debug(`locking ${step} using ${lockFile}`);
+
+        const unlock = await lockfile.lock(lockFile);
+
+        const result = await callback();
+
+        logger.debug(`unlocking ${step} from ${lockFile}`);
+
+        unlock();
+
+        return result;
+    }
+    else {
+        logger.trace(`asynchronous ${step}`);
+        return await callback();
+    }
+}
 
 module.exports = { handle };

package/lib/handler.js

@@ -4,7 +4,8 @@ const lockfile = require('proper-lockfile');
 const { dynamic_handler, moveTo } = require('../lib/util');
 const piscina = require('piscina');
 const chokidar = require('chokidar');
-const logger = require('../lib/util.js').getLogger();
+const logger = require('../lib/util').getLogger();
+const { parseAsJSON } = require('../lib/util');
 
 async function handle_inbox(path,options) {
     if (options.single) {
@@ -150,8 +151,17 @@ async function inboxProcessor(pool,path,options) {
 
                     logger.info(`adding ${fullPath} to queue`);
 
+                    const notification = parseAsJSON(fullPath);
+
                     promises.push(
-                        pool.run({path: fullPath, options: options}, { name: 'handle'})
+                        pool.run({
+                            path: fullPath, 
+                            options: options, 
+                            config: {}, 
+                            notification: notification
+                            }, 
+                            { name: 'handle'}
+                        )
                     );
 
                     locks.push(lock);

package/lib/index.js

@@ -17,15 +17,18 @@ const { handle_inbox } = require('../lib/handler');
 const logger = getLogger();
 
 function doInbox(req,res,opts) {
-    if (req.method === 'GET' && opts['inboxPublic'] == 1) {
+    if (req.method === 'GET') {
         doInboxGET(req,res,opts);
     }
-    else if (req.method == 'HEAD' && opts['inboxPublic'] == 1) {
+    else if (req.method == 'HEAD') {
         doInboxHEAD(req,res,opts);
     }
     else if (req.method === 'POST' && opts['inboxWriteable'] == 1) {
         doInboxPOST(req,res,opts);
     }
+    else if (req.method === 'OPTIONS') {
+        doInboxOPTIONS(req,res,opts);
+    }
     else { 
         logger.error(`tried method ${req.method} on inbox : forbidden`);
         res.writeHead(403);
@@ -50,6 +53,88 @@ function doInboxGET(req,res,opts) {
     }
 }
 
+function doInboxOPTIONS(req,res,opts) {
+    const pathItem = req.url.substring(opts['url'].length);
+    const id = pathItem.substring(1);
+
+    logger.debug(`doInboxOPTIONS (for ${pathItem})`);
+
+    if (pathItem === '/')  {
+        const meta = getBody(`${id}.meta`,opts);
+   
+        let metadata = {};
+
+        if (meta) {
+            metadata = JSON.parse(meta);
+        }
+
+        const allow = ['GET','HEAD','OPTIONS'];
+
+        if (opts['inboxWriteable'] == 1) {
+            allow.push('POST');
+            metadata['Accept-Post'] = 'application/ld+json';
+        }
+
+        metadata['Allow'] = allow.join(",");
+
+        logger.debug(metadata);
+        
+        for (let property in metadata) {
+            if (property !== 'Content-Type') {
+                res.setHeader(property,metadata[property]);
+            }
+        }
+
+        res.writeHead(200);
+        res.end();
+        return;
+    }
+
+    if (pathItem.match(/^\/[A-Za-z0-9_-]+\.jsonld$/)) {
+        const result = getBody(id,opts);
+
+        if (! result) {
+            res.writeHead(403);
+            res.end('Forbidden');
+            return;
+        }
+
+        const meta = getBody(`${id}.meta`,opts);
+       
+        let metadata = {};
+
+        if (meta) {
+            metadata = JSON.parse(meta);
+        }
+        
+        const allow = ['OPTIONS'];
+
+        if (opts['inboxPublic'] == 1) {
+            allow.push('GET');
+            allow.push('HEAD');
+        }
+
+        metadata['Allow'] = allow.join(",");
+
+        logger.debug(metadata);
+
+        for (let property in metadata) {
+            if (property !== 'Content-Type') {
+                res.setHeader(property,metadata[property]);
+            }
+        }
+
+        res.writeHead(200);
+        res.end(); 
+        return;
+    }
+    else {
+        res.writeHead(403);
+        res.end('Forbidden');
+        return;
+    }
+}
+
 function doInboxHEAD(req,res,opts) {
     const pathItem = req.url.substring(opts['url'].length);
     const id = pathItem.substring(1);
@@ -73,7 +158,7 @@ function doInboxHEAD(req,res,opts) {
         return;
     }
 
-    if (pathItem.match(/^\/[A-Za-z0-9_-]+\.jsonld$/)) {
+    if (pathItem.match(/^\/[A-Za-z0-9_-]+\.jsonld$/) && opts['inboxPublic'] == 1) {
         const result = getBody(id,opts);
 
         if (! result) {
@@ -106,9 +191,13 @@ function doInboxHEAD(req,res,opts) {
 }
 
 function doInboxGET_Index(req,res,opts) {
-    const notifications = listInbox(opts).map( (e) => {
-        return opts['base'] + '/' + opts['url'] + e;
-    });
+    let notifications = [];
+
+    if (opts['inboxPublic'] == 1) {
+        notifications = listInbox(opts).map( (e) => {
+            return opts['base'] + '/' + opts['url'] + e;
+        });
+    }
 
     const result = {
         "@context": "http://www.w3.org/ns/ldp",
@@ -137,7 +226,7 @@ function doInboxGET_Read(req,res,opts) {
     const id = pathItem.substring(1);
     const result = getBody(id,opts);
 
-    if (result) {
+    if (result && opts['inboxPublic'] == 1) {
         const meta = getBody(`${id}.meta`,opts);
         
         if (meta) {
@@ -192,10 +281,19 @@ function doInboxPOST(req,res,opts) {
         logger.debug(postData);
         if (checkBody(postData,opts)) {
             const id = storeBody(postData,opts);
-            logger.debug(`accepted ${req.url}${id}`);
-            res.setHeader('Location',`${req.url}${id}`);
-            res.writeHead(201);
-            res.end(`Accepted ${req.url}${id}`);
+            if (opts['inboxPublic'] == 1) {
+                const message = `Accepted ${req.url}${id}`;
+                logger.debug(message);
+                res.setHeader('Location',`${req.url}${id}`);
+                res.writeHead(201);
+                res.end(message);
+            }
+            else {
+                const message = JSON.stringify({"message":"Request accepted"});
+                logger.debug(`202 : ${message}`);
+                res.writeHead(202);
+                res.end(message);
+            }
         }
         else {
             logger.error(`not-accepted post`);
@@ -254,10 +352,13 @@ function storeBody(data,opts) {
 }
 
 function checkBody(data,opts) {
-    if (! (opts['schema'] && fs.existsSync(opts['schema']))) {
+    if (! opts['schema'] || ! fs.existsSync(opts['schema'])) {
         logger.debug(`no JSON_SCHEMA found`);
         return true;
     }
+    else {
+        logger.debug(`using schema: ${opts['schema']}`);
+    }
     try {
         const JSON_SCHEMA = JSON.parse(fs.readFileSync(opts['schema'], { encoding: 'utf-8'}));
         const json = JSON.parse(data);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ldn-inbox-server",
-  "version": "1.7.1",
+  "version": "1.8.0",
   "description": "A demonstration Event Notifications Inbox server",
   "main": "lib/index.js",
   "author": "Patrick Hochstenbach <Patrick.Hochstenbach@UGent.be>",
@@ -14,7 +14,7 @@
     "handle-inbox-multi": "npx ldn-inbox-server handler @inbox -hn @handler/notification_handler/multi.js",
     "handle-outbox-multi": "npx ldn-inbox-server handler @outbox -hn @handler/notification_handler/multi.js",
     "handle-inbox-multi-loop": "npx ldn-inbox-server handler @inbox -hn @handler/notification_handler/multi.js --loop",
-    "clean": "rm -rf error/* inbox/* outbox/* public/events/* public/events/log/* public/artifacts/artifact1 public/artifacts/artifact2 public/artifacts/*.jsonld*"
+    "real-clean": "rm -rf error/* inbox/* outbox/* public/events/* public/events/log/* public/artifacts/artifact1 public/artifacts/artifact2 public/artifacts/*.jsonld*"
   },
   "bin": "./bin/ldn-inbox-server.js",
   "keywords": [