ldn-inbox-server 1.3.2 → 1.4.0

package/README.md

@@ -119,7 +119,7 @@ A handler that creates for an incoming notification an `Accept` notification in
 
 A handler that updates an event log with the incoming notification. 
 
-Requires a configuration file with property `notification_handler.eventlog`:
+Requires configuration properties:
 
 - `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)
@@ -127,6 +127,25 @@ Requires a configuration file with property `notification_handler.eventlog`:
 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`.
 
+### Json Path handler
+
+A handler that accepts a notifiction when it matches one or more JSON paths
+
+Requires configuration properties:
+
+- anyOf : an array of json path matchers, the combination should be interpreted as a logical `OR`.
+   - every json path matcher is an array of single matchers, the combination should be interpered as a logical `AND`.
+  
+A single matcher needs two properties:
+
+- path : a json path
+- value : a value
+
+The json path matches when one of:
+
+- On the json path an array is found and the value is included in the array
+- On the json path a string or number is found and the value is equal to this string or number
+
 ### 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`.
@@ -135,19 +154,37 @@ A `handler/multi_notification_handler.js` is available to start multiple handler
 
 A handler to `Offer` an event log to a memento server.
 
-Requires a configuration file with property `notification_handler.offer_memento`:
+Requires configuration properties:
 
 - `actor`: the LDN+AS2 `actor` to use in a notification
 - `target`: the LDN+AS2 `target` to use in a notification
 
-### Send handler
+### Send notification handler
 
-A hanlder to send notification that live in the `@outbox` via the LDN protocol to the LDN `target`.
+A handler to send notification that live in the `@outbox` via the LDN protocol to the LDN `target`.
 
-### Valid artifact
+### Type handler
+
+A handler that accepts any notification with a type that matches one of the `anyOf` types.
+
+### Valid artifact handler
 
 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.
 
+Generates the following options keys:
+
+- artifact.id : the URL of the artifact
+- artifact.path : the local path to the artifact
+
+### Valid event log handler
+
+A hander that validates the incoming notification and checks if the `object` or `context` contains an event log that is part of the `public` resources.
+
+Generates the following options keys:
+
+- eventlog.id : the URL of the event log
+- eventlog.path : the local path of the event log
+
 ## Artifact support 
 
 This code base contains Event Notifications support for Data Node artifacts. See the examples

package/bin/ldn-inbox-server.js

@@ -69,15 +69,7 @@ program
       }
         break;
     }
-    if (options['loop']) {
-      while(1) {
-        await handle_inbox(box,options); 
-        await new Promise(resolve => setTimeout(resolve, options['loop']*1000));
-      }
-    }
-    else {
-      await handle_inbox(box,options);
-    }
+    await handle_inbox(box,options);
   });
 
-  program.parse();
+program.parse();

package/bin/post-notification.js

@@ -16,9 +16,24 @@ program
   .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);  
+
+     let to = url;
+
+     if (to === '@me') {
+        to = `${INBOX_BASE_URL}/${INBOX_URL}`;
+     }
+     else if (to === '@target') {
+        to = json['target']['inbox'];
+     }
+     
+     if (!to) {
+        logger.error('no "to" inbox found');
+     }
+     else {
+        logger.info(`sending notification to ${to}`);
+        await sendNotification(to,json);  
+     }
   });
 
 program.parse();

package/config/inbox_config.json

@@ -1,31 +1,50 @@
 {
     "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"
+                [
+                 { 
+                    "id": "handler/notification_handler/jsonpath_filter.js",
+                    "anyOf": [ 
+                        [ 
+                            { "path": "$.type" , "value": "Offer" } 
+                        ]
+                    ]
+                 }, 
+                 "handler/notification_handler/valid_artifact.js" ,
+                 {
+                    "id": "handler/notification_handler/eventlog.js",
+                    "log": "@artifact:strip@.jsonld",
+                    "dir": "@artifact:strip@"
+                 },
+                 {
+                    "id": "handler/notification_handler/offer_memento.js",
+                    "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"
+                    }
+                 }
+                ] ,
+                [
+                  { 
+                    "id": "handler/notification_handler/jsonpath_filter.js",
+                    "anyOf": [ 
+                        [ 
+                            { "path": "$.type" , "value": "Announce" } ,
+                            { "path": "$.actor.id", "value": "https://labs.eventnotifications.net/service/m/profile/card.ttl" }
+                        ]
+                    ]
+                 } ,
+                 "handler/notification_handler/valid_eventlog.js",
+                 "handler/notification_handler/add_timemap_link.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

@@ -1,14 +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"
+                [
+                "handler/notification_handler/send_notification.js",
+                {
+                    "id": "handler/eventlog_notification_handler.js",
+                    "log": "@artifact:strip@.jsonld",
+                    "dir": "@artifact:strip@" 
+                }
+                ]
             ]
         }
     }

package/ecosystem.config.js-example

@@ -0,0 +1,16 @@
+module.exports = {
+  apps : [
+   {
+    name   : "ldn-inbox-server",
+    script : "./bin/ldn-inbox-server.js start-server"
+   } ,
+   {
+    name   : "ldn-inbox-inbox",
+    script : "LOG4JS=info ./bin/ldn-inbox-server.js handler @inbox --loop 20 -hn ./handler/notification_handler/multi.js"
+   } ,
+   {
+    name   : "ldn-inbox-outbox",
+    script : "LOG4JS=info ./bin/ldn-inbox-server.js handler @outbox --loop 20 -hn ./handler/notification_handler/multi.js"
+   } 
+ ]
+}

package/examples/memento_announce.jsonld

@@ -0,0 +1,27 @@
+{
+    "@context": [
+      "https://www.w3.org/ns/activitystreams",
+      {
+        "ietf": "https://www.iana.org/"
+      }
+    ],
+    "type": "Announce",
+    "actor": {
+      "id": "https://labs.eventnotifications.net/service/m/profile/card.ttl",
+      "inbox": "https://labs.eventnotifications.net/service/m/inbox/",
+      "type": "Service"
+    },
+    "context": "http://localhost:8000/artifacts/artifact1.jsonld",
+    "inReplyTo": "urn:uuid:6E5FAF88-A7F1-47A4-B087-77345EBFF495",
+    "object": {
+      "id": "https://labs.eventnotifications.net/service/m/map/http://localhost:8000/artifacts/artifact1.jsonld",
+      "type": "Document",
+      "ietf:original": "http://localhost:8000/artifacts/artifact1.jsonld",
+      "ietf:memento": "https://labs.eventnotifications.net/service/m/memento/http://localhost:8000/artifacts/artifact1.jsonld/6c7f984b0702a16b6b9661ea7dca2db48fa8086d"
+    },
+    "target": {
+      "id": "http://193.190.80.48:56633/service/r/profile/card#me",
+      "type": "Service",
+      "inbox": "http://193.190.80.48:56633/service/r/inbox/"
+    }
+  }

package/handler/{demo_inbox_handler.js → inbox_handler/demo.js}

@@ -6,7 +6,7 @@ const fs = require('fs');
  * 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}) {
+async function handle({path,options,config}) {
     console.log(`handleInbox(${path},..)`);
     fs.readdir(path, (err,files) => {
         files.forEach( (file) => {

package/handler/{accept_notification_handler.js → notification_handler/accept.js}

@@ -1,14 +1,14 @@
 const fs = require('fs');
 const md5 = require('md5');
-const { parseAsJSON } = require('../lib/util');
-const logger = require('../lib/util.js').getLogger();
+const { parseAsJSON } = require('../../lib/util.js');
+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}) {
+async function handle({path,options,config}) {
     logger.info(`parsing notification ${path}`);
     
     try {
@@ -47,7 +47,7 @@ async function handle({path,options}) {
     }
     catch(e) {
         logger.error(`failed to process ${path}`);
-        logger.debug(e);
+        logger.error(e);
         return { path, options, success: false };
     }
 }

package/handler/notification_handler/add_timemap_link.js

@@ -0,0 +1,51 @@
+const fs = require('fs');
+const jp = require('jsonpath');
+const { parseAsJSON } = require('../../lib/util.js');
+const logger = require('../../lib/util.js').getLogger();
+
+/**
+ * Demonstration event log handler
+ */
+async function handle({path,options,config}) {
+    logger.info(`parsing notification ${path}`);
+
+    const eventlog = options['eventlog'];
+
+    if (!eventlog) {
+        logger.error(`no eventlog option available (do you run valid_eventlog first?)`);
+        return { path, options, success: false };
+    }
+
+    try {
+        const json = parseAsJSON(path);
+
+        const meta = parseAsJSON(`${eventlog['path']}.meta`);
+     
+        const timemap = jp.query(json,'$.object.id');
+        const relation = `<${timemap}> ; rel="timemap"`;
+
+        let links = meta['Link'] || [];
+        
+        if (links.includes(relation)) {
+            // Do nothing
+        }        
+        else {
+            links.push(`<${timemap}> ; rel="timemap"`);
+        }
+
+        meta['Link'] = links;
+
+        logger.info(`Writing ${meta['Link']} to ${eventlog['path']}.meta`);
+
+        fs.writeFileSync(`${eventlog['path']}.meta`,JSON.stringify(meta,null,4));
+        
+        return { path, options, success: true };
+    }
+    catch(e) {
+        logger.error(`failed to process ${path}`);
+        logger.error(e);
+        return { path, options, success: false };
+    }
+}
+
+module.exports = { handle };

package/handler/{eventlog_notification_handler.js → notification_handler/eventlog.js}

@@ -1,26 +1,20 @@
 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 logger = require('../../lib/util.js').getLogger();
 
 /**
  * Demonstration event log handler
  */
-async function handle({path,options}) {
+async function handle({path,options,config}) {
     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']) {
+    if (!config['log'] || !config['dir']) {
         logger.error('no log/dir entry for notification_handler.eventlog configuration'); 
         return { path, options, success: false };
     }
@@ -30,8 +24,8 @@ async function handle({path,options}) {
                         `http://${options['host']}:${options['port']}` :
                             'http://localhost:8000';
 
-    let eventLog = thisConfig['log'];
-    let eventDir = thisConfig['dir'];
+    let eventLog = config['log'];
+    let eventDir = config['dir'];
 
     let artifactPath = undefined;
 

package/handler/notification_handler/jsonpath_filter.js

@@ -0,0 +1,84 @@
+const jp = require('jsonpath');
+const { parseAsJSON } = require('../../lib/util.js');
+const logger = require('../../lib/util.js').getLogger();
+
+/**
+ * Demonstration notification handler, that checks if the notification
+ * matches a configurable list
+ */
+async function handle({path,options,config}) {
+    logger.info(`parsing notification ${path}`);
+    
+    if (! config) {
+        logger.error('no configuration found for eventlog_notification_handler');
+        return { path, options, success: false };
+    }
+
+    if (! (config['anyOf'] && Array.isArray(config['anyOf']))) {
+        logger.error('no anyOf entry in notification_handler.type_filer should be an array'); 
+        return { path, options, success: false };
+    }
+
+    try {
+        const anyOf = config['anyOf'];
+        const json  = parseAsJSON(path);
+        
+        let isOk = false;
+
+        for (let i = 0 ; i < anyOf.length ; i++) {
+            let matchCount = 0;
+            for (let j = 0 ; j < anyOf[i].length ; j++) {
+                const anyPart = anyOf[i][j];
+                const path  = anyPart['path'];
+                const value = anyPart['value'];
+                
+                const jsonValue = jp.query(json,path);
+
+                if (jsonValue !== null || jsonValue !== undefined) {
+                    if (Array.isArray(jsonValue)) {
+                        if (jsonValue.includes(value)) {
+                            // Yup ..
+                            logger.info(`found ${path} includes ${value} `)
+                            matchCount++;
+                        }
+                        else {
+                            // Nope ..
+                        }
+                    }
+                    else if (typeof jsonValue === 'string' || typeof jsonValue === 'number') {
+                        if (jsonValue === value) {
+                            // Yup ..
+                            logger.info(`found ${path} === ${value} `)
+                            matchCount++
+                        }
+                        else {
+                            // Nope ..
+                        }
+                    }
+                    else {
+                        // Nope ..
+                    }
+                }
+            }
+            if (matchCount == anyOf[i].length) {
+                isOk = true;
+                break;
+            }
+        }
+
+        if (isOk) {
+            return { path, options, success: true };
+        }
+        else {
+            logger.error(`notification does not pass jsonpath_filter check`);
+            return { path, options, success: false };
+        }
+    }
+    catch(e) {
+        logger.error(`failed to process ${path}`);
+        logger.error(e);
+        return { path, options, success: false };
+    }
+}
+
+module.exports = { handle };

package/handler/notification_handler/multi.js

@@ -0,0 +1,96 @@
+const { dynamic_handler , parseAsJSON } = require('../../lib/util.js');
+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 };
+    }
+
+    logger.info(`starting multi handler`);
+       
+    let workflow_success = 0;
+    let workflow_errors = 0;
+
+    for (let i = 0 ; i < handlers.length ; i++) {
+        const workflow = handlers[i];
+
+        let thisWorkflow = true;
+
+        try {
+            for (let j = 0 ; j < workflow.length ; j++) {
+                let step = undefined;
+                let config = undefined;
+
+                if (typeof workflow[j] === 'string' || workflow[j] instanceof String) {
+                    step = workflow[j];
+                    config = {};
+                }
+                else {
+                    step = workflow[j]['id'];
+                    delete workflow[j]['id']; 
+                    config = workflow[j];
+                }
+
+                logger.info(`workflow[${i}] : starting ${step}`);
+
+                const handler = dynamic_handler(step,null);
+
+                if (! handler) {
+                    throw new Error(`failed to load ${step}`);
+                }
+
+                const result = await handler({path,options,config});
+            
+                if (result['success']) {
+                    logger.info(`workflow[${i}] : finished ${step}`);
+                }
+                else {
+                    logger.error(`workflow[${i}] : failed ${step}`);
+                    thisWorkflow = false;
+                    break;
+                }
+            }
+        }
+        catch (e) {
+            logger.error(`failed to process ${path}`);
+            logger.error(e);
+            thisWorkflow = false;
+        }
+
+        if (thisWorkflow) {
+            workflow_success++;
+        }
+        else {
+            workflow_errors++;
+        }
+    }
+
+    if (handlers.length > 0 && workflow_success > 0) {
+        success = true;
+    }
+    else {
+        success = false;
+    }
+
+    logger.info(`finished multi handler`);
+
+    return { path, options, success: success };
+}   
+
+module.exports = { handle };

package/handler/{offer_memento_notification_handler.js → notification_handler/offer_memento.js}

@@ -1,26 +1,21 @@
 const fs = require('fs');
 const md5 = require('md5');
-const { parseAsJSON } = require('../lib/util.js');
-const logger = require('../lib/util.js').getLogger();
+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}) {
+async function handle({path,options,config}) {
     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']) {
+    if (!config['actor'] || !config['target']) {
         logger.error('no actor/target entry for notification_handler.eventlog configuration'); 
         return { path, options, success: false };
     }
@@ -42,12 +37,12 @@ async function handle({path,options}) {
                 {"schema": "https://schema.org/"}
             ], 
             type: 'Offer',
-            actor: thisConfig['actor'],
+            actor: config['actor'],
             object: {
                 id: options['eventlog']['id'],
                 type: [ "Document", "schema:Dataset" ]
             },
-            target: thisConfig['target']
+            target: config['target']
         },null,4);
 
         const outboxFile = options['outbox'] + '/' + md5(data) + '.jsonld';
@@ -60,7 +55,7 @@ async function handle({path,options}) {
     }
     catch(e) {
         logger.error(`failed to process ${path}`);
-        logger.debug(e);
+        logger.error(e);
         return { path, options, success: false };
     }
 }

package/handler/{send_notification_handler.js → notification_handler/send_notification.js}

@@ -1,11 +1,11 @@
-const logger = require('../lib/util.js').getLogger();
-const { sendNotification , parseAsJSON } = require('../lib/util.js');
+const logger = require('../../lib/util.js').getLogger();
+const { sendNotification , parseAsJSON } = require('../../lib/util.js');
 
 /**
  * Demonstration notification handler that sends a notification to a
  * target inbox. 
  */
-async function handle({path,options}) {
+async function handle({path,options,config}) {
     try {
         const data = parseAsJSON(path);
         const type = data['type'];

package/handler/{type_filter_notification_handler.js → notification_handler/type_filter.js}

@@ -1,29 +1,19 @@
-const fs = require('fs');
-const { parseAsJSON } = require('../lib/util');
-const logger = require('../lib/util.js').getLogger();
+const { parseAsJSON } = require('../../lib/util.js');
+const logger = require('../../lib/util.js').getLogger();
 
 /**
  * Demonstration notification handler, that checks if the notification
  * matches a configurable list
  */
-async function handle({path,options}) {
+async function handle({path,options,config}) {
     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']))) {
+    if (! (config['anyOf'] && Array.isArray(config['anyOf']))) {
         logger.error('no anyOf entry in notification_handler.type_filer should be an array'); 
         return { path, options, success: false };
     }
@@ -38,7 +28,7 @@ async function handle({path,options}) {
         let isOk = true ;
 
         for (let i = 0 ; i < typeArray.length ; i++) {
-            if (thisConfig['anyOf'].includes(typeArray[i])) {
+            if (config['anyOf'].includes(typeArray[i])) {
                 // We are ok
             }
             else {
@@ -57,7 +47,7 @@ async function handle({path,options}) {
     }
     catch(e) {
         logger.error(`failed to process ${path}`);
-        logger.debug(e);
+        logger.error(e);
         return { path, options, success: false };
     }
 }

package/handler/{valid_artifact_notification_handler.js → notification_handler/valid_artifact.js}

@@ -1,11 +1,11 @@
-const { ldPropertyAsId , parseArtifact, parseAsJSON } = require('../lib/util.js');
-const logger = require('../lib/util.js').getLogger();
+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}) {
+async function handle({path,options,config}) {
     logger.info(`parsing notification ${path}`);
     
     try {
@@ -47,7 +47,7 @@ async function handle({path,options}) {
     }
     catch(e) {
         logger.error(`failed to process ${path}`);
-        logger.debug(e);
+        logger.error(e);
         return { path, options, success: false };
     }
 }

package/handler/notification_handler/valid_eventlog.js

@@ -0,0 +1,52 @@
+const { ldPropertyAsId , parseEventLog, 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,config}) {
+    logger.info(`parsing notification ${path}`);
+    
+    try {
+        const json = parseAsJSON(path);
+        
+        let eventlog = undefined;
+
+        if (ldPropertyAsId(json['context'])) {
+            eventlog = ldPropertyAsId(json['context']);
+        }
+        else {
+            logger.error(`failed to find valid context or object`);
+            return { path, options, success: false };
+        }
+
+        if (! eventlog) {
+            logger.error(`failed to find eventlog`);
+            return { path, options, success: false };
+        }
+
+        const eventLogPath = parseEventLog(eventlog,options);
+
+        if (eventLogPath) {
+            // Storing the eventlog path to the options. 
+            // Maybe bad practice..but it is a workflow attribute like in Nifi :P
+            options['eventlog'] = {
+                'id': eventlog ,
+                'path': eventLogPath
+            };
+            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.error(e);
+        return { path, options, success: false };
+    }
+}
+
+module.exports = { handle };

package/lib/handler.js

@@ -23,35 +23,45 @@ async function defaultInboxHandler({path,options}) {
         maxQueue: queue_size
     });
 
-    try {
-        const [prms,locks] = await inboxProcessor(pool,path,options);
-        const results = await Promise.all(prms);
-
-        for (let i = 0 ; i < results.length ; i++) {
-            const result = results[i];
-            const success = result['success'];
-            const notification = result['path'];
-
-            if (success) {
-                logger.info(`processing ${notification} is a success`);
-                if (fs.existsSync(notification)) {
-                    logger.debug(`removing ${notification}`);
-                    fs.unlinkSync(result['path']);
+    const loopWait = options['loop'] || 0;
+
+    do {
+        try {
+            const [prms,locks] = await inboxProcessor(pool,path,options);
+            const results = await Promise.all(prms);
+
+            for (let i = 0 ; i < results.length ; i++) {
+                const result = results[i];
+                const success = result['success'];
+                const notification = result['path'];
+
+                if (success) {
+                    logger.info(`processing ${notification} is a success`);
+                    if (fs.existsSync(notification)) {
+                        logger.debug(`removing ${notification}`);
+                        fs.unlinkSync(result['path']);
+                    }
                 }
+                else {
+                    logger.warn(`processing ${notification} is a failure`);
+                    logger.debug(`moving ${notification} to ${options['error']}`);
+                    moveTo(notification,options['error']);
+                }
+
+                // release lock
+                if (locks[i]) locks[i]();
             }
-            else {
-                logger.warn(`processing ${notification} is a failure`);
-                logger.debug(`moving ${notification} to ${options['error']}`);
-                moveTo(notification,options['error']);
-            }
+        }
+        catch (e) {
+            logger.error(e);
+        }
 
-            // release lock
-            if (locks[i]) locks[i]();
+        if (loopWait) {
+            logger.debug(`sleep ${loopWait} secs...`);
+            await new Promise(resolve => setTimeout(resolve, loopWait*1000));
         }
     }
-    catch (e) {
-        logger.error(e);
-    }
+    while (loopWait > 0);
 }
 
 async function inboxProcessor(pool,path,options) {

package/lib/util.js

@@ -156,6 +156,40 @@ function ldPropertyAsId(object_or_string) {
 
 function parseArtifact(url,options) {
     logger.debug(`isArtifact(${url})?`);
+
+    const resource = parseLocalResource(url,options);
+
+    if (resource === null)  {
+        return null;
+    }
+
+    const { filePath , metaPath , json} = resource;
+
+    if (json['X-Artifact']) {
+        return filePath;
+    }
+    else {
+        return null;
+    }
+}
+
+function parseEventLog(url,options) {
+    logger.debug(`isEventLog(${url})?`);
+
+    const resource = parseLocalResource(url,options);
+
+    if (resource === null)  {
+        return null;
+    }
+
+    const { filePath , metaPath , json} = resource;
+
+    return filePath;
+}
+
+function parseLocalResource(url,options) {
+    logger.debug(`isLocalResource(${url})?`);
+
     const base = options['base'] ? options['base'] : 
                     options['host'] && options['port'] ? 
                         `http://${options['host']}:${options['port']}` :
@@ -163,9 +197,9 @@ function parseArtifact(url,options) {
 
     const public = options['public'];
 
-    const filePath = url.substring(base.length + 1);
+    const filePath = `${public}/` + url.substring(base.length + 1);
 
-    const metaPath = `${public}/${filePath}.meta`;
+    const metaPath = `${filePath}.meta`;
 
     logger.debug(`searching ${metaPath}`);
     
@@ -181,12 +215,7 @@ function parseArtifact(url,options) {
         return null;
     }
 
-    if (json['X-Artifact']) {
-        return `${public}/${filePath}`;
-    }
-    else {
-        return null;
-    }
+    return { filePath, metaPath, json };
 }
 
 module.exports = { 
@@ -198,5 +227,7 @@ module.exports = {
     dynamic_handler ,
     parseAsJSON ,
     parseArtifact ,
+    parseEventLog ,
+    parseLocalResource ,
     ldPropertyAsId
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ldn-inbox-server",
-  "version": "1.3.2",
+  "version": "1.4.0",
   "description": "A demonstration Event Notifications Inbox server",
   "main": "lib/index.js",
   "author": "Patrick Hochstenbach <Patrick.Hochstenbach@UGent.be>",
@@ -8,11 +8,11 @@
   "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/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",
-    "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",
+    "handle-inbox": "npx ldn-inbox-server handler @inbox -hn ./handler/notification_handler/accept.js",
+    "handle-outbox": "npx ldn-inbox-server handler @outbox -hn ./handler/notification_handler/send_notification.js",
+    "handle-eventlog": "npx ldn-inbox-server handler @inbox -hn handler/notification_handler/eventlog.js",
+    "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",
     "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",
@@ -25,6 +25,7 @@
     "commander": "^12.0.0",
     "dotenv": "^16.4.5",
     "exponential-backoff": "^3.1.1",
+    "jsonpath": "^1.1.1",
     "jsonschema": "^1.4.1",
     "md5": "^2.3.0",
     "mellon-server": "^1.0.8",

package/handler/multi_notification_handler.js

@@ -1,61 +0,0 @@
-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 };