ldn-inbox-server 1.2.1 → 1.2.2

package/{.env → .env-example}

@@ -2,6 +2,7 @@ LOG4JS=INFO
 LDN_SERVER_HOST=localhost
 LDN_SERVER_PORT=8000
 LDN_SERVER_INBOX_GLOB="^.*\.jsonld$"
+LDN_SERVER_BASEURL=http://localhost:8000
 LDN_SERVER_INBOX_BATH_SIZE=5
 LDN_SERVER_INBOX_URL=inbox/
 LDN_SERVER_INBOX_PATH=./inbox

package/README.md

@@ -45,14 +45,17 @@ npx ldn-inbox-server handle @outbox
 ## Environment
 
 - `LOG4JS` : log4js logging level
-- `LDN_SERVER_HOST` : default LDN inbox host
-- `LDN_SERVER_PORT` : default LDN inbox port
-- `LDN_SERVER_INBOX_URL` : default LDN inbox url (path)
-- `LDN_SERVER_INBOX_PATH` : default LDN inbox path
-- `LDN_SERVER_ERROR_PATH` : default LDN error path
-- `LDN_SERVER_OUTBOX_PATH` : default LDN outbox path
-- `LDN_SERVER_PUBLIC_PATH` : default public (HTML) path
-- `LDN_SERVER_JSON_SCHEMA` : default notification JSON validation schema
+- `LDN_SERVER_HOST` : LDN inbox host
+- `LDN_SERVER_PORT` : LDN inbox port
+- `LDN_SERVER_INBOX_URL` : LDN inbox url (path)
+- `LDN_SERVER_INBOX_PATH` : LDN inbox path
+- `LDN_SERVER_ERROR_PATH` : LDN error path
+- `LDN_SERVER_OUTBOX_PATH` : LDN outbox path
+- `LDN_SERVER_PUBLIC_PATH` : public (HTML) path
+- `LDN_SERVER_JSON_SCHEMA` : notification JSON validation schema
+- `LDN_SERVER_BASEURL` : baseurl of the LDN inbox server
+- `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 inbox
 
 ## Extend
 

package/bin/ldn-inbox-server.js

@@ -11,26 +11,30 @@ const PORT = process.env.LDN_SERVER_PORT ?? 8000;
 const INBOX_GLOB = process.env.LDN_SERVER_INBOX_GLOB ?? "^.*\\.jsonld$";
 const INBOX_BATCH_SIZE = process.env.LDN_SERVER_INBOX_BATH_SIZE ?? 5;
 const INBOX_URL = process.env.LDN_SERVER_INBOX_URL ?? 'inbox/';
+const INBOX_BASE_URL = process.env.LDN_SERVER_BASEURL ?? 'http://localhost:8000';
 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 HAS_PUBLIC = process.env.LDN_SERVER_HAS_PUBLIC_INBOX ?? 0;
 
 program
   .name('lnd-inbox-server')
-  .version('1.2.1')
+  .version('1.2.2')
   .description('A demonstration Event Notifications Inbox server');
 
 program
   .command('start-server')
   .option('--host <host>','host',HOST)
   .option('--port <port>','port',PORT)
-  .option('--url <url>','url',INBOX_URL)
+  .option('--url <path>','path',INBOX_URL)
+  .option('--base <url>','base url',INBOX_BASE_URL)
   .option('--inbox <inbox>','inbox',INBOX_PATH)
   .option('--public <public>','public',PUBLIC_PATH)
   .option('--schema <schema>','json schema',JSON_SCHEMA_PATH)
   .option('--registry <registry>','registry',null)
+  .option('--inbox-public','public readable inbox',HAS_PUBLIC)
   .action( (options) => {
     inbox_server(options);
   });
@@ -39,6 +43,7 @@ program
   .command('handler')
   .option('--inbox <inbox>','inbox',INBOX_PATH)
   .option('--outbox <outbox>','outbox',OUTBOX_PATH)
+  .option('--public <public>','public',PUBLIC_PATH)
   .option('--error <errbox>','errbox',ERROR_PATH)
   .option('--loop <seconds>', 'run in a loop',0)
   .option('--batch_size <num>','batch size to process',INBOX_BATCH_SIZE)

package/handler/demo_inbox_handler.js

@@ -1,5 +1,7 @@
 const fs = require('fs');
 
+// Demonstration of an inbox handler (don't use it the one in lib/handler.js 
+// is much more mature)
 async function handle({path,options}) {
     console.log(`handleInbox(${path},..)`);
     fs.readdir(path, (err,files) => {

package/handler/eventlog_notification_handler.js

@@ -0,0 +1,103 @@
+const fs = require('fs');
+const fsPath = require('path');
+const lockfile = require('proper-lockfile');
+const logger = require('../lib/util.js').getLogger();
+
+const EVENT_DIR = 'events';
+const EVENT_LOG = 'events.jsonld';
+
+async function handle({path,options}) {
+    logger.info(`parsing notification ${path}`);
+    
+    try {
+        const json = JSON.parse(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 });
+        }
+  
+        const outboxFile = fsPath.join(logDir,fileName);
+
+        fs.writeFileSync(outboxFile, JSON.stringify(json));
+
+        // Updating metadata file
+        const metaFile = outboxFile + '.meta';
+
+        fs.writeFileSync(metaFile, JSON.stringify({
+            'Content-Type': 'application/ld+json',
+            'Last-Modified': nowISO()
+        },null,4));
+
+        await updateEventLog({path,options});
+
+        return { path,options, success: true };
+    }
+    catch(e) {
+        logger.error(`failed to process ${path}`);
+        logger.error(e);
+        return { path,options, success: false };
+    }
+}
+
+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 eventLog = fsPath.join(options['public'],EVENT_DIR,EVENT_LOG);
+
+        let json;
+        
+        if (fs.existsSync(eventLog)) {
+            json = JSON.parse(fs.readFileSync(eventLog, { encoding: 'utf-8'}));
+        }
+        else {
+            json = {
+                "@context": "https://labs.eventnotifications.net/contexts/eventlog.jsonld",
+                "type": "EventLog",
+                "member": []
+            };
+        }
+     
+        if (json['member'].findIndex( (e) => e === entry) >= 0) {
+            logger.info(`${entry} already in ${eventLog}`);
+        }
+        else {
+            logger.info(`updating ${eventLog}`);
+
+            json['member'].push(entry);
+
+            if (fs.existsSync(eventLog)) {
+                try {
+                    const lock = await lockfile(eventLog, { retries: 10 });
+                    fs.writeFileSync(eventLog,JSON.stringify(json,null,4));
+                    lock(); // release
+                }
+                catch (e) {
+                    logger.error(`failed to update ${eventLog}`);
+                }
+            }
+            else {
+                fs.writeFileSync(eventLog,JSON.stringify(json,null,4));
+            }
+        }
+
+        return true;
+    }
+    catch (e) {
+        return false;
+    }
+}
+
+function nowISO() {
+    return (new Date()).toUTCString();
+}
+
+module.exports = { handle };

package/lib/index.js

@@ -14,11 +14,15 @@ const logger = getLogger();
 
 let INBOX_URL = 'inbox/';
 let INBOX_PATH = './inbox';
+let INBOX_BASE_URL = 'http://localhost:8000';
+let INBOX_PUBLIC_READABLE = 0;
 let JSON_SCHEMA = '';
 
 function inbox_server(options) {
     INBOX_URL = options['url'];
     INBOX_PATH = options['inbox'];
+    INBOX_BASE_URL = options['base'];
+    INBOX_PUBLIC_READABLE = options['inboxPublic'];
     JSON_SCHEMA = JSON.parse(fs.readFileSync(options['schema'], { encoding: 'utf-8'}));
     let registry = [{ path : `${INBOX_URL}.*` , do: doInbox }];
 
@@ -44,12 +48,113 @@ function inbox_server(options) {
 }
 
 function doInbox(req,res) {
-    if (req.method !== 'POST') {
+    if (req.method === 'GET' && INBOX_PUBLIC_READABLE) {
+        doInboxGET(req,res);
+    }
+    if (req.method == 'HEAD' && INBOX_PUBLIC_READABLE) {
+        doInboxHEAD(req,res);
+    }
+    else if (req.method === 'POST') {
+        doInboxPOST(req,res);
+    }
+    else { 
         logger.error(`tried method ${req.method} on inbox : forbidden`);
         res.writeHead(403);
         res.end('Forbidden');
         return;
     }
+}
+
+function doInboxGET(req,res) {
+    const pathItem = req.url.substring(INBOX_URL.length);
+
+    logger.debug(`doInboxGET (for ${pathItem})`);
+
+    if (pathItem === '/')  {
+        doInboxGET_Index(req,res);
+    }
+    else if (pathItem.match(/^\/[a-z0-9]+\.jsonld$/)) {
+        doInboxGET_Read(req,res);
+    }
+    else {
+        res.writeHead(403);
+        res.end('Forbidden');
+    }
+}
+
+function doInboxHEAD(req,res) {
+    const pathItem = req.url.substring(INBOX_URL.length);
+
+    logger.debug(`doInboxHEAD (for ${pathItem})`);
+
+    if (pathItem === '/')  {
+        res.setHeader('Content-Type','application/ld+json');
+        res.writeHead(200);
+        res.end();
+        return;
+    }
+
+    if (pathItem.match(/^\/[a-z0-9]+\.jsonld$/)) {
+        const id = pathItem.substring(1);
+        const result = getBody(id);
+
+        if (result) {
+            res.setHeader('Content-Type','application/ld+json');
+            res.writeHead(200);
+            res.end(); 
+            return;
+        }
+        else {
+            res.writeHead(403);
+            res.end('Forbidden');
+        }
+    }
+    else {
+        res.writeHead(403);
+        res.end('Forbidden');
+        return;
+    }
+}
+
+function doInboxGET_Index(req,res) {
+    const notifications = listInbox().map( (e) => {
+        return INBOX_BASE_URL + '/' + INBOX_URL + e;
+    });
+
+    const result = {
+        "@context": "http://www.w3.org/ns/ldp",
+        "@id": INBOX_BASE_URL + '/' + INBOX_URL,
+        "contains": notifications
+    };
+
+    res.writeHead(200);
+    res.end(JSON.stringify(result,null,2));
+}
+
+function doInboxGET_Read(req,res) {
+    const pathItem = req.url.substring(INBOX_URL.length);
+
+    const result = getBody(pathItem.substring(1));
+
+    if (result) {
+        res.setHeader('Content-Type','application/ld+json');
+        res.writeHead(200);
+        res.end(result);
+    }
+    else {
+        res.writeHead(403);
+        res.end('Forbidden'); 
+    }
+}
+
+function doInboxPOST(req,res) {
+    const pathItem = req.url.substring(INBOX_URL.length);
+
+    if (pathItem !== '/') {
+        req.writeHead(403);
+        res.end('Forbidden');
+        return;
+    }
 
     const headers = req.headers;
 
@@ -88,6 +193,35 @@ function doInbox(req,res) {
     });
 }
 
+function listInbox() {
+    const glob = new RegExp("^.*\\.jsonld$");
+
+    logger.debug(`listInbox()`);
+
+    try {
+        const entries = fs.readdirSync(INBOX_PATH).filter( (file) => {
+            return file.match(glob);
+        });
+        return entries;
+    }
+    catch(e) {
+        logger.error(e);
+        return [];
+    }
+}
+
+function getBody(id) {
+    logger.debug(`getBody(${id})`);
+
+    try {
+        return fs.readFileSync(INBOX_PATH + '/' + id, {encoding : 'utf-8'});
+    }
+    catch(e) {
+        logger.error(e);
+        return null;
+    }
+}
+
 function storeBody(data) {
     try {
         const id = md5(data);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ldn-inbox-server",
-  "version": "1.2.1",
+  "version": "1.2.2",
   "description": "A demonstration Event Notifications Inbox server",
   "main": "lib/index.js",
   "author": "Patrick Hochstenbach <Patrick.Hochstenbach@UGent.be>",
@@ -10,6 +10,7 @@
     "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-eventlog": "npx ldn-inbox-server handler @inbox -hn handler/eventlog_notification_handler.js",
     "clean": "rm error/* inbox/* outbox/*"
   },
   "bin": "./bin/ldn-inbox-server.js",