ldn-inbox-server 1.2.2 → 1.3.1

package/.env-example

@@ -9,4 +9,7 @@ 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

package/README.md

@@ -33,13 +33,13 @@ curl -X POST -H 'Content-Type: application/ld+json' --data-binary '@examples/off
 Start an inbox handler with a demo handler (that creates an `Accept` message in the `./outbox`).
 
 ```
-npx ldn-inbox-server handle @inbox -hn ./handler/demo_notification_handler.js
+npx ldn-inbox-server handler @inbox -hn ./handler/accept_notification_handler.js
 ```
 
-Send the notifications in the outbox:
+Start an outbox handler that send the notifications that are available outbox:
 
 ```
-npx ldn-inbox-server handle @outbox
+npx ldn-inbox-server handler @outbox -hn ./handler/send_notification_handler.js
 ```
 
 ## Environment
@@ -62,7 +62,7 @@ npx ldn-inbox-server handle @outbox
 Server extensions are possible by providing custom inbox and notification handlers. E.g.
 
 ```
-npx ldn-inbox-server handle-inbox -hn handler/demo_notification_handler.js
+npx ldn-inbox-server handler @inbox -hn handler/my_handler.js
 ```
 
 Or, in JavaScript:
@@ -74,12 +74,19 @@ main();
 
 async function main() {
     await handle_inbox('./inbox', {
-        'notification_handler': 'handler/worker.js' 
+        'inbox': './inbox',
+        'outbox': './outbox',
+        'public': './public',
+        'error': './error',
+        'batch_size': 5,
+        'glob': '^.*\\.jsonld$',
+        'config': './config/inbox_config.json',
+        'notification_handler': 'handler/my_handler.js' 
     });
 }
 ```
 
-with `worker.js` :
+with `my_handler.js` :
 
 ```
 async function handle({path,options}) {
@@ -102,6 +109,54 @@ A handler can be started on any directory. E.g. a workflow might be:
 - processed LDN messages will end up in the "outbox" box
 - invalid processing will be saved into the "error" box  
 
+## Handlers
+
+### Accept handler
+
+A handler that creates for an incoming notification an `Accept` notification in the `@outbox`.
+
+### Evenlog handler
+
+A handler that updates an event log with the incoming notification. 
+
+Requires a configuration file with property `notification_handler.eventlog`:
+
+- `log`: the path to the event log (starting from the `public` directory)
+- `dir`: the path to a container to store the events (starting from the `public` directory)
+
+The `log` and `dir` path may contain a `@artifact(:strip)?@` directive to fill in the
+path of the current artifact. The `:strip` filter is used to strip an artifact path of a file extension. E.g. `path/artifact.html` becomes `path/artifact` when using a `:strip`.
+
+### Multi handler
+
+A `handler/multi_notification_handler.js` is available to start multiple handler for each notification messages. The handlers to start are specified in a configuraton file that can be passed via the `config` parameter of an `handle_inbox`. In the commmand line tool `bin/ldn-inbox-server` the default location of such config file is `config/inbox_config.json` when processing an `@inbox`, and `config/outbox_config.json` when processing an `@outbox`.
+
+### Offer memento handler
+
+A handler to `Offer` an event log to a memento server.
+
+Requires a configuration file with property `notification_handler.offer_memento`:
+
+- `actor`: the LDN+AS2 `actor` to use in a notification
+- `target`: the LDN+AS2 `target` to use in a notification
+
+### Send handler
+
+A hanlder to send notification that live in the `@outbox` via the LDN protocol to the LDN `target`.
+
+### Valid artifact
+
+A handler that validates the incoming notification and checks if the `object` or `context` contains an artifact that is part of the `public` resources. See 'Artifact support' below.
+
+## Artifact support 
+
+This code base contains Event Notifications support for Data Node artifacts. See the examples
+in `public/artifacts-example`. Move this directory tp `public/artifacts` to get a running example.
+
+- Each artifact requires at least a `.meta` file with the `X-Artifact` header set to `true` to be recognized by the software as an artifact
+- Each artifact should update the `Link-Template` header in the `.meta` file
+- The config files in `config/inbox_config.json` and `config/outbox_config.json` define the location of the possible event logs for the artifact
+  
 ## See also
 
 - [mellon-server](https://www.npmjs.com/package/mellon-server)

package/bin/ldn-inbox-server.js

@@ -1,9 +1,9 @@
 #!/usr/bin/env node
 
-const path = require('path');
+const fs = require('fs');
 const { program } = require('commander');
 const { inbox_server } = require('../lib/index');
-const { handle_inbox , defaultSendNotificationHandler } = require('../lib/handler');
+const { handle_inbox } = require('../lib/handler');
 require('dotenv').config();
 
 const HOST = process.env.LDN_SERVER_HOST ?? 'localhost';
@@ -17,11 +17,12 @@ 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 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;
 
 program
   .name('lnd-inbox-server')
-  .version('1.2.2')
   .description('A demonstration Event Notifications Inbox server');
 
 program
@@ -41,6 +42,7 @@ program
 
 program
   .command('handler')
+  .option('--base <url>','base url',INBOX_BASE_URL)
   .option('--inbox <inbox>','inbox',INBOX_PATH)
   .option('--outbox <outbox>','outbox',OUTBOX_PATH)
   .option('--public <public>','public',PUBLIC_PATH)
@@ -48,6 +50,7 @@ program
   .option('--loop <seconds>', 'run in a loop',0)
   .option('--batch_size <num>','batch size to process',INBOX_BATCH_SIZE)
   .option('--glob <glob>','files to process in inbox',INBOX_GLOB)
+  .option('--config <path>','config file for handlers')
   .option('-hi,--inbox_handler <handler>','inbox handler')
   .option('-hn,--notification_handler <handler>','notification handler')
   .argument('<box>','box to process')
@@ -55,11 +58,15 @@ program
     switch (box) {
       case '@inbox':
         box = INBOX_PATH;
+        if (!options['config'] && fs.existsSync(INBOX_CONFIG)) {
+            options['config'] = INBOX_CONFIG
+        }
         break;
       case '@outbox':
         box = OUTBOX_PATH;
-        options['notification_handler'] =
-           options['notification_handler'] ?? path.join(__dirname,'..','lib','sendNotificationHandler.js');
+        if (!options['config'] && fs.existsSync(OUTBOX_CONFIG)) {
+          options['config'] = OUTBOX_CONFIG
+      }
         break;
     }
     if (options['loop']) {

package/bin/post-notification.js

@@ -0,0 +1,24 @@
+#!/usr/bin/env node
+
+const fs = require('fs');
+const { program } = require('commander');
+const { sendNotification, getLogger } = require('../lib/util.js');
+require('dotenv').config();
+
+const logger = getLogger();
+
+const INBOX_URL = process.env.LDN_SERVER_INBOX_URL ?? 'inbox/';
+const INBOX_BASE_URL = process.env.LDN_SERVER_BASEURL ?? 'http://localhost:8000';
+
+program
+  .name('post-notification')
+  .description('A LDN notification sender')
+  .argument('<url>','notification')
+  .argument('<file>','notification')
+  .action( async(url,file) => {
+     const to = url === '@me' ? `${INBOX_BASE_URL}/${INBOX_URL}` : url;
+     const json = JSON.parse(fs.readFileSync(file, { encoding: 'utf-8'}));
+     await sendNotification(to,json);  
+  });
+
+program.parse();

package/config/inbox_config.json

@@ -0,0 +1,31 @@
+{
+    "notification_handler": {
+        "eventlog": {
+            "log": "@artifact:strip@.jsonld",
+            "dir": "@artifact:strip@"
+        },
+        "multi": {
+            "handlers": [
+                "handler/type_filter_notification_handler.js",
+                "handler/valid_artifact_notification_handler.js" ,
+                "handler/eventlog_notification_handler.js",
+                "handler/offer_memento_notification_handler.js"
+            ]
+        },
+        "offer_memento": {
+            "actor": {
+                "id": "http://localhost:8000/profile/card#me" ,
+                "inbox": "http://localhost:8000/inbox/" ,
+                "type": "Service"
+            },
+            "target": {
+                "id": "http://localhost:8001/profile/card#me" ,
+                "inbox": "http://localhost:8001/inbox/" ,
+                "type": "Service"
+            }
+        },
+        "type_filter": {
+            "anyOf": [ "Offer" ]
+        }
+    }
+}

package/config/outbox_config.json

@@ -0,0 +1,15 @@
+{
+    "notification_handler": {
+        "eventlog": {
+            "log": "@artifact:strip@.jsonld",
+            "dir": "@artifact:strip@"
+        },
+        "multi": {
+            "handlers": [
+                "handler/valid_artifact_notification_handler.js" ,
+                "handler/send_notification_handler.js",
+                "handler/eventlog_notification_handler.js"
+            ]
+        }
+    }
+}

package/examples/offer.jsonld

@@ -7,11 +7,11 @@
     "type": "Offer",
     "actor": {
        "id": "https://acme.org.xyz/profile/card#us",
-       "inbox": "https://acme.org.xyz/inbox/",
+       "inbox": "http://localhost:8000/inbox/",
        "type": "Organization"
     },
     "object": {
-       "id": "http://acme.org.xyz/artifacts/alice/data-set-2022-01-19.zip",
+       "id": "http://localhost:8000/artifacts/artifact1.html",
        "type": [ "Document" , "schema:Dataset" ]
     },
     "target": {

package/handler/{demo_notification_handler.js → accept_notification_handler.js}

@@ -1,23 +1,26 @@
 const fs = require('fs');
+const md5 = require('md5');
+const { parseAsJSON } = require('../lib/util');
 const logger = require('../lib/util.js').getLogger();
 
+/**
+ * Demonstration notification handler, that creates an 'Accept'
+ * notification for each incoming notification message and stores
+ * it in the outbox container.
+ */
 async function handle({path,options}) {
     logger.info(`parsing notification ${path}`);
     
     try {
-        const json = JSON.parse(fs.readFileSync(path, { encoding: 'utf-8'}));
+        const json = parseAsJSON(path);
         
-        const outboxFile = options['outbox'] + '/' + path.split('/').pop();
-
         const id = json['id'];
         const object = json['object'];
         const actor_id = json['actor']['id'];
         const actor_type = json['actor']['type'];
         const actor_inbox = json['actor']['inbox'];
 
-        logger.info(`storing Accept to ${outboxFile}`);
-
-        fs.writeFileSync(outboxFile, JSON.stringify({
+        const data = JSON.stringify({
             type: 'Accept',
             actor: {
                 id: 'http://my.server' ,
@@ -32,13 +35,20 @@ async function handle({path,options}) {
                 type: actor_type ,
                 inbox: actor_inbox
             }
-        },null,2));
-        return { path,options, success: true };
+        },null,4);
+
+        const outboxFile = options['outbox'] + '/' + md5(data) + '.jsonld';
+
+        logger.info(`storing Accept to ${outboxFile}`);
+
+        fs.writeFileSync(outboxFile,data);
+
+        return { path, options, success: true };
     }
     catch(e) {
         logger.error(`failed to process ${path}`);
         logger.debug(e);
-        return { path,options, success: false };
+        return { path, options, success: false };
     }
 }
 

package/handler/demo_inbox_handler.js

@@ -1,7 +1,11 @@
 const fs = require('fs');
 
-// Demonstration of an inbox handler (don't use it the one in lib/handler.js 
-// is much more mature)
+/** 
+ * Demonstration of an alternatve inbox handler
+ *   (don't use it the one in lib/handler.js is much more mature)
+ * To use it set it via the `--hi` option of `bin/ldn-inbox-server.js`, or
+ * the `inbox_handler` option of the `handle_inbox` function.
+ */
 async function handle({path,options}) {
     console.log(`handleInbox(${path},..)`);
     fs.readdir(path, (err,files) => {

package/handler/eventlog_notification_handler.js

@@ -1,45 +1,121 @@
 const fs = require('fs');
+const md5 = require('md5');
 const fsPath = require('path');
 const lockfile = require('proper-lockfile');
+const { parseAsJSON } = require('../lib/util');
 const logger = require('../lib/util.js').getLogger();
 
-const EVENT_DIR = 'events';
-const EVENT_LOG = 'events.jsonld';
-
+/**
+ * Demonstration event log handler
+ */
 async function handle({path,options}) {
     logger.info(`parsing notification ${path}`);
-    
+
+    const config = parseAsJSON(options['config']);
+
+    if (! config) {
+        logger.error('no configuration found for eventlog_notification_handler');
+        return { path, options, success: false };
+    }
+
+    const thisConfig = config['notification_handler']?.['eventlog'];
+
+    if (! thisConfig || !thisConfig['log'] || !thisConfig['dir']) {
+        logger.error('no log/dir entry for notification_handler.eventlog configuration'); 
+        return { path, options, success: false };
+    }
+
+    const base = options['base'] ? options['base'] : 
+                    options['host'] && options['port'] ? 
+                        `http://${options['host']}:${options['port']}` :
+                            'http://localhost:8000';
+
+    let eventLog = thisConfig['log'];
+    let eventDir = thisConfig['dir'];
+
+    let artifactPath = undefined;
+
+    if (options['artifact']) {
+        artifactPath = options['artifact']['id'].substring(base.length+1);
+        logger.info(artifactPath);
+    }
+
+    if (eventLog.match(/@artifact(:[a-zA-Z]+)?@/)) {
+        if (options['artifact']) {
+            if (eventLog.match(/@artifact:strip@/)) {
+                eventLog = eventLog.replaceAll(/@artifact(:[a-zA-Z]+)?@/g,artifactPath.replaceAll(/\.\w+$/g,''));
+            }
+            else {
+                eventLog = eventLog.replaceAll(/@artifact(:[a-zA-Z]+)?@/g,artifactPath);
+            }
+        }
+        else {
+            logger.error(`requested to parse ${eventLog} but no artifact information available`);
+            return { path, options, success: false };
+        }
+    } 
+
+    if (eventDir.match(/@artifact(:[a-zA-Z]+)?@/)) {
+        if (options['artifact']) {
+            if (eventDir.match(/@artifact:strip@/)) {
+                eventDir = eventDir.replaceAll(/@artifact(:[a-zA-Z]+)?@/g,artifactPath.replaceAll(/\.\w+$/g,''));
+            }
+            else {
+                eventDir = eventDir.replaceAll(/@artifact(:[a-zA-Z]+)?@/g,artifactPath);
+            }
+        }
+        else {
+            logger.error(`requested to parse ${eventDir} but no artifact information available`);
+            return { path, options, success: false };
+        }
+    } 
+
     try {
-        const json = JSON.parse(fs.readFileSync(path, { encoding: 'utf-8'}));
+        const json = fs.readFileSync(path, { encoding: 'utf-8' });
       
         const fileName = path.split('/').pop();
-        const logDir = fsPath.join(options['public'],EVENT_DIR,'log');
 
-        if (! fs.existsSync(logDir)) {
-            logger.info(`creating ${logDir}`);
-            fs.mkdirSync(logDir, { recursive : true });
+        if (! fs.existsSync(`${options['public']}/${eventDir}`)) {
+            logger.info(`creating ${options['public']}/${eventDir}`);
+            fs.mkdirSync(`${options['public']}/${eventDir}`, { recursive : true });
         }
-  
-        const outboxFile = fsPath.join(logDir,fileName);
 
-        fs.writeFileSync(outboxFile, JSON.stringify(json));
+        const eventFile = `${options['public']}/${eventDir}/${fileName}`;
+
+        fs.writeFileSync(eventFile, json);
 
         // Updating metadata file
-        const metaFile = outboxFile + '.meta';
+        const metaFile = `${options['public']}/${eventLog}.meta`;
 
         fs.writeFileSync(metaFile, JSON.stringify({
             'Content-Type': 'application/ld+json',
             'Last-Modified': nowISO()
         },null,4));
 
+        // Store the path in the options .. yeah yeah we know ugly but it works for now
+     
+        const eventPath = `${eventDir}/${fileName}`;
+        const eventId = `${base}/${eventPath}`;
+        const eventLogId = `${base}/${eventLog}`;
+
+        options['eventlog'] = {
+            'id': eventLogId ,
+            'file': `${options['public']}/${eventLog}` ,
+            'dir': `${options['public']}/${eventDir}` ,
+            'item': {
+                'id' : eventId ,
+                'file' : eventFile 
+            }
+        };
+
         await updateEventLog({path,options});
 
-        return { path,options, success: true };
+        return { path, options, success: true };
     }
     catch(e) {
         logger.error(`failed to process ${path}`);
         logger.error(e);
-        return { path,options, success: false };
+        return { path, options, success: false };
     }
 }
 
@@ -47,11 +123,11 @@ async function updateEventLog({path,options}) {
     logger.info(`updating eventlog for ${path}`);
 
     try {
-        const baseUrl = process.env.LDN_SERVER_BASEURL ?? "";
-        const fileName = path.split('/').pop();
-        const entry = `${baseUrl}/${EVENT_DIR}/log/${fileName}`;
+        const notification = fs.readFileSync(path, { encoding: 'utf-8'});
+        const notification_checksum = md5(notification);
 
-        const eventLog = fsPath.join(options['public'],EVENT_DIR,EVENT_LOG);
+        const entry = options['eventlog']['item']['id'];
+        const eventLog = options['eventlog']['file'];
 
         let json;
         
@@ -66,13 +142,20 @@ async function updateEventLog({path,options}) {
             };
         }
      
-        if (json['member'].findIndex( (e) => e === entry) >= 0) {
+        if (json['member'].findIndex( (e) => e['id'] === entry) >= 0) {
             logger.info(`${entry} already in ${eventLog}`);
         }
         else {
             logger.info(`updating ${eventLog}`);
 
-            json['member'].push(entry);
+            json['member'].push({
+                "id": entry ,
+                "checksum": {
+                    "type": "Checksum",
+                    "algorithm": "spdx:checksumAlgorithm_md5",
+                    "checksumValue": notification_checksum
+                }
+            });
 
             if (fs.existsSync(eventLog)) {
                 try {

package/handler/multi_notification_handler.js

@@ -0,0 +1,61 @@
+const { dynamic_handler , parseAsJSON } = require('../lib/util');
+const logger = require('../lib/util.js').getLogger();
+
+/**
+ * Demonstration notification handler that start multiple notification handlers.
+ * Requires a config file that specifies which handlers to start. 
+ */
+async function handle({path,options}) {
+    let success = false;
+
+    const config = parseAsJSON(options['config']);
+
+    if (! config) {
+        logger.error('no configuration found for multi_notification_handler');
+        return { path, options, success: false };
+    }
+
+    const handlers = config['notification_handler']?.['multi']?.['handlers'];
+
+    if (! handlers) {
+        logger.error('no notification_handler.multi.handlers key in configuration file');
+        return { path, options, success: false };
+    }
+
+    try {
+        logger.info(`starting multi handler`);
+        
+        for (let i = 0 ; i < handlers.length ; i++) {
+            logger.info(`starting ${handlers[i]}`);
+
+            const handler = dynamic_handler(handlers[i],null);
+
+            if (! handler) {
+                throw new Error(`failed to load ${handlers[i]}`);
+            }
+
+            const result = await handler({path,options});
+           
+            if (result['success']) {
+                logger.info(`finished ${handlers[i]}`);
+            }
+            else {
+                throw new Error(`Eek! ${handlers[i]} failed`);
+            }
+        }
+
+        success = true;
+    }
+    catch (e) {
+        logger.error(`failed to process ${path}`);
+        logger.error(e);
+
+        success = false;
+    }
+
+    logger.info(`finished multi handler`);
+
+    return { path, options, success: success };
+}   
+
+module.exports = { handle };

package/handler/offer_memento_notification_handler.js

@@ -0,0 +1,68 @@
+const fs = require('fs');
+const md5 = require('md5');
+const { parseAsJSON } = require('../lib/util.js');
+const logger = require('../lib/util.js').getLogger();
+
+/**
+ * Demonstration notification handler, that creates an 'Offer'
+ * notification for each incoming notificaation to request the
+ * archivation of the event log.
+ */
+async function handle({path,options}) {
+    logger.info(`parsing notification ${path}`);
+
+    const config = parseAsJSON(options['config']);
+
+    if (! config) {
+        logger.error('no configuration found for offer_memento_notification_handler');
+        return { path, options, success: false };
+    }
+   
+    const thisConfig = config['notification_handler']?.['offer_memento'];
+
+    if (! thisConfig || !thisConfig['actor'] || !thisConfig['target']) {
+        logger.error('no actor/target entry for notification_handler.eventlog configuration'); 
+        return { path, options, success: false };
+    }
+
+    if (!options['artifact']) {
+        logger.info(`no artifact found (ignonring this request)`);
+        return { path, options, success: true };
+    }
+
+    if (!options['eventlog']) {
+        logger.info(`no artifact found (ignonring this request)`);
+        return { path, options, success: true };
+    }
+
+    try {
+        const data = JSON.stringify({
+            '@context': [ 
+                "https://www.w3.org/ns/activitystreams" ,
+                {"schema": "https://schema.org/"}
+            ], 
+            type: 'Offer',
+            actor: thisConfig['actor'],
+            object: {
+                id: options['eventlog']['id'],
+                type: [ "Document", "schema:Dataset" ]
+            },
+            target: thisConfig['target']
+        },null,4);
+
+        const outboxFile = options['outbox'] + '/' + md5(data) + '.jsonld';
+
+        logger.info(`storing Offer to ${outboxFile}`);
+
+        fs.writeFileSync(outboxFile,data);
+
+        return { path, options, success: true };
+    }
+    catch(e) {
+        logger.error(`failed to process ${path}`);
+        logger.debug(e);
+        return { path, options, success: false };
+    }
+}
+
+module.exports = { handle };

package/{lib/sendNotificationHandler.js → handler/send_notification_handler.js}

@@ -1,10 +1,13 @@
-const fs = require('fs');
 const logger = require('../lib/util.js').getLogger();
-const { sendNotification } = require('../lib/util.js');
+const { sendNotification , parseAsJSON } = require('../lib/util.js');
 
+/**
+ * Demonstration notification handler that sends a notification to a
+ * target inbox. 
+ */
 async function handle({path,options}) {
     try {
-        const json = fs.readFileSync(path, { encoding: 'utf-8'});
+        const json = parseAsJSON(path);
         const data = JSON.parse(json);
         const type = data['type'];
         let inbox;

package/handler/type_filter_notification_handler.js

@@ -0,0 +1,65 @@
+const fs = require('fs');
+const { parseAsJSON } = require('../lib/util');
+const logger = require('../lib/util.js').getLogger();
+
+/**
+ * Demonstration notification handler, that checks if the notification
+ * matches a configurable list
+ */
+async function handle({path,options}) {
+    logger.info(`parsing notification ${path}`);
+    
+    const config = parseAsJSON(options['config']);
+
+    if (! config) {
+        logger.error('no configuration found for eventlog_notification_handler');
+        return { path, options, success: false };
+    }
+
+    const thisConfig = config['notification_handler']?.['type_filter'];
+
+    if (! thisConfig) {
+        logger.error('no notification_handler.type_filer configuration'); 
+        return { path, options, success: false };
+    }
+
+    if (! (thisConfig['anyOf'] && Array.isArray(thisConfig['anyOf']))) {
+        logger.error('no anyOf entry in notification_handler.type_filer should be an array'); 
+        return { path, options, success: false };
+    }
+
+    try {
+        const json = parseAsJSON(path);
+        
+        const type = json['type'];
+
+        const typeArray = Array.isArray(type) ? type : [type];
+
+        let isOk = true ;
+
+        for (let i = 0 ; i < typeArray.length ; i++) {
+            if (thisConfig['anyOf'].includes(typeArray[i])) {
+                // We are ok
+            }
+            else {
+                logger.error(`${typeArray[i]} does not pass type_filter check`);
+                isOk = false;
+                break;
+            }       
+        }
+
+        if (isOk) {
+            return { path, options, success: true };
+        }
+        else {
+            return { path, options, success: false };
+        }
+    }
+    catch(e) {
+        logger.error(`failed to process ${path}`);
+        logger.debug(e);
+        return { path, options, success: false };
+    }
+}
+
+module.exports = { handle };

package/handler/valid_artifact_notification_handler.js

@@ -0,0 +1,55 @@
+const { ldPropertyAsId , parseArtifact, parseAsJSON } = require('../lib/util.js');
+const logger = require('../lib/util.js').getLogger();
+
+/**
+ * Demonstration notification handler, that checks if the notification
+ * message contains an artifact that is known to the data node
+ */
+async function handle({path,options}) {
+    logger.info(`parsing notification ${path}`);
+    
+    try {
+        const json = parseAsJSON(path);
+        
+        let artifact = undefined;
+
+        if (ldPropertyAsId(json['context'])) {
+            artifact = ldPropertyAsId(json['context']);
+        }
+        else if (ldPropertyAsId(json['object'])) {
+            artifact = ldPropertyAsId(json['object']);
+        }
+        else {
+            logger.error(`failed to find valid context or object`);
+            return { path, options, success: false };
+        }
+
+        if (!artifact) {
+            logger.error(`failed to find artifact`);
+            return { path, options, success: false };
+        }
+
+        const artifactPath = parseArtifact(artifact,options);
+
+        if (artifactPath) {
+            // Storing the artifact path to the options. 
+            // Maybe bad practice..but it is a workflow attribute like in Nifi :P
+            options['artifact'] = {
+                'id': artifact ,
+                'path': artifactPath
+            };
+            return { path, options, success: true };
+        }
+        else {
+            logger.error(`artifact ${artifact} is not known here...`);
+            return { path, options, success: false };
+        }
+    }
+    catch(e) {
+        logger.error(`failed to process ${path}`);
+        logger.debug(e);
+        return { path, options, success: false };
+    }
+}
+
+module.exports = { handle };

package/lib/handler.js

@@ -17,6 +17,7 @@ async function defaultInboxHandler({path,options}) {
 
     const worker = options['notification_handler'] ?? fsPath.resolve(__dirname,'..','lib','notification.js');
 
+    // Run the notifications using a node.js worker pool
     const pool = new piscina({
         filename: worker,
         maxQueue: queue_size

package/lib/index.js

@@ -42,16 +42,17 @@ function inbox_server(options) {
     start_server({
         host: options['host'],
         port: options['port'],
+        base: options['base'],
         public: options['public'],
         registry: registry
     });
 }
 
 function doInbox(req,res) {
-    if (req.method === 'GET' && INBOX_PUBLIC_READABLE) {
+    if (req.method === 'GET' && INBOX_PUBLIC_READABLE == 1) {
         doInboxGET(req,res);
     }
-    if (req.method == 'HEAD' && INBOX_PUBLIC_READABLE) {
+    else if (req.method == 'HEAD' && INBOX_PUBLIC_READABLE == 1) {
         doInboxHEAD(req,res);
     }
     else if (req.method === 'POST') {
@@ -61,7 +62,6 @@ function doInbox(req,res) {
         logger.error(`tried method ${req.method} on inbox : forbidden`);
         res.writeHead(403);
         res.end('Forbidden');
-        return;
     }
 }
 

package/lib/util.js

@@ -67,7 +67,7 @@ async function sendNotification(url,json,options) {
             'Accept': 'application/json',
             'Content-Type': 'application/json'
         },
-        body: JSON.stringify(json)
+        body: JSON.stringify(json,null,4)
     });
 
     if (! response.ok) {
@@ -125,11 +125,78 @@ function dynamic_handler(handler,fallback) {
     }
 }
 
+function parseAsJSON(path) {
+    try {
+        return JSON.parse(fs.readFileSync(path, { encoding: 'utf-8'}));
+    }
+    catch (e) {
+        logger.error(`failed to parse ${path}`);
+        return null;
+    }
+}
+
+function ldPropertyAsId(object_or_string) {
+    if (!object_or_string) {
+        return null;
+    }
+
+    if (typeof object_or_string === 'string' || object_or_string instanceof String) {
+        return object_or_string;
+    }
+    else if (typeof object_or_string === 'object' && object_or_string['id']) {
+        return object_or_string['id'];
+    }
+    else if (typeof object_or_string === 'object' && object_or_string['@id']) {
+        return object_or_string['@id'];
+    }
+    else {
+        return null;
+    }
+}
+
+function parseArtifact(url,options) {
+    logger.debug(`isArtifact(${url})?`);
+    const base = options['base'] ? options['base'] : 
+                    options['host'] && options['port'] ? 
+                        `http://${options['host']}:${options['port']}` :
+                            'http://localhost:8000';
+
+    const public = options['public'];
+
+    const filePath = url.substring(base.length + 1);
+
+    const metaPath = `${public}/${filePath}.meta`;
+
+    logger.debug(`searching ${metaPath}`);
+    
+    if (! fs.existsSync(metaPath)) {
+        logger.debug(`no such file ${metaPath}`);
+        return null;
+    }
+
+    const json = parseAsJSON(metaPath);
+
+    if (json === null)  {
+        logger.debug(`no json at ${metaPath}`);
+        return null;
+    }
+
+    if (json['X-Artifact']) {
+        return `${public}/${filePath}`;
+    }
+    else {
+        return null;
+    }
+}
+
 module.exports = { 
     getLogger , 
     backOff_fetch , 
     fetchOriginal ,
     moveTo ,
     sendNotification ,
-    dynamic_handler
+    dynamic_handler ,
+    parseAsJSON ,
+    parseArtifact ,
+    ldPropertyAsId
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ldn-inbox-server",
-  "version": "1.2.2",
+  "version": "1.3.1",
   "description": "A demonstration Event Notifications Inbox server",
   "main": "lib/index.js",
   "author": "Patrick Hochstenbach <Patrick.Hochstenbach@UGent.be>",
@@ -8,10 +8,12 @@
   "scripts": {
     "server": "npx ldn-inbox-server start-server",
     "demo-post": "curl -X POST -H 'Content-Type: application/ld+json' --data-binary '@examples/offer.jsonld' http://localhost:8000/inbox/",
-    "handle-inbox": "npx ldn-inbox-server handler @inbox -hn ./handler/demo_notification_handler.js",
-    "handle-outbox": "npx ldn-inbox-server handler @outbox",
+    "handle-inbox": "npx ldn-inbox-server handler @inbox -hn ./handler/accept_notification_handler.js",
+    "handle-outbox": "npx ldn-inbox-server handler @outbox -hn ./handler/send_notification_handler.js",
     "handle-eventlog": "npx ldn-inbox-server handler @inbox -hn handler/eventlog_notification_handler.js",
-    "clean": "rm error/* inbox/* outbox/*"
+    "handle-inbox-multi": "npx ldn-inbox-server handler @inbox -hn ./handler/multi_notification_handler.js",
+    "handle-outbox-multi": "npx ldn-inbox-server handler @outbox -hn ./handler/multi_notification_handler.js",
+    "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": [
@@ -25,10 +27,11 @@
     "exponential-backoff": "^3.1.1",
     "jsonschema": "^1.4.1",
     "md5": "^2.3.0",
-    "mellon-server": "^1.0.4",
+    "mellon-server": "^1.0.8",
     "node-fetch": "1.7.3",
     "piscina": "^4.4.0",
     "proper-lockfile": "^4.1.2",
+    "upath": "^2.0.1",
     "uuid": "^9.0.1"
   }
 }

package/public/artifacts-example/artifact1.html

@@ -0,0 +1,17 @@
+<html>
+    <head>
+        <link
+        rel="stylesheet"
+        href="https://cdn.jsdelivr.net/npm/@picocss/pico@2/css/pico.min.css"
+        />
+        <title>Artifact 1</title>
+    </head>
+    <body>
+        <main class="container">
+            <h1>Artifact 1</h1>
+            <p>
+                <a href="artifact1.jsonld">Event Log</a>
+            </p>
+        </main>
+    </body>
+</html>

package/public/artifacts-example/artifact1.html.meta

@@ -0,0 +1,6 @@
+{
+    "Content-Type": "text/html",
+    "X-Artifact": true,
+    "Link-Template": "\"https://{YOUR-SERVER}/artifacts/artifact1.jsonld\"; rel=\"eventlog\"",
+    "Link": "</inbox/> ; rel=\"http://www.w3.org/ns/ldp#inbox\""
+}

package/public/artifacts-example/artifact2.html

@@ -0,0 +1,17 @@
+<html>
+    <head>
+        <link
+        rel="stylesheet"
+        href="https://cdn.jsdelivr.net/npm/@picocss/pico@2/css/pico.min.css"
+        />
+        <title>Artifact 2</title>
+    </head>
+    <body>
+        <main class="container">
+            <h1>Artifact 2</h1>
+            <p>
+                <a href="artifact1.jsonld">Event Log</a>
+            </p>
+        </main>
+    </body>
+</html>

package/public/artifacts-example/artifact2.html.meta

@@ -0,0 +1,6 @@
+{
+    "Content-Type": "text/html",
+    "X-Artifact": true,
+    "Link-Template": "\"https://{YOUR-SERVER}/artifacts/artifact2.jsonld\"; rel=\"eventlog\"",
+    "Link": "</inbox/> ; rel=\"http://www.w3.org/ns/ldp#inbox\""
+}

package/public/index.html.meta

@@ -0,0 +1,3 @@
+{
+    "Content-Type": "text/html"
+}