event-storage 0.7.2 → 0.9.1

package/src/Watcher.js

@@ -1,15 +1,16 @@
 const fs = require('fs');
 const path = require('path');
-const EventEmitter = require('events');
+const events = require('events');
 const { assert } = require('./util');
 
-const directoryWatchers = {};
+/** @type {Map<string, DirectoryWatcher>} */
+const directoryWatchers = new Map();
 
 /**
  * A reference counting singleton nodejs watcher for directories.
  * Emits events 'change' and 'rename' with the file name as argument.
  */
-class DirectoryWatcher extends EventEmitter {
+class DirectoryWatcher extends events.EventEmitter {
 
     /**
      * @param {string} directory
@@ -18,14 +19,17 @@ class DirectoryWatcher extends EventEmitter {
      */
     constructor(directory, options = {}) {
         directory = path.normalize(directory);
-        assert(fs.existsSync(directory), 'Can not watch a non-existing directory.');
 
-        if (directoryWatchers[directory]) {
-            directoryWatchers[directory].references++;
-            return directoryWatchers[directory];
+        if (directoryWatchers.has(directory)) {
+            const watcher = directoryWatchers.get(directory);
+            watcher.references++;
+            return watcher;
         }
+        assert(fs.existsSync(directory), `Can not watch a non-existing directory "${directory}".`);
+        assert(fs.statSync(directory).isDirectory(), `Can only watch directories, but "${directory}" is none.`);
         super();
-        directoryWatchers[directory] = this;
+        this.setMaxListeners(1000);
+        directoryWatchers.set(directory, this);
         this.directory = directory;
         this.watcher = fs.watch(directory, Object.assign({ persistent: false }, options), this.emit.bind(this));
         this.references = 1;
@@ -40,7 +44,7 @@ class DirectoryWatcher extends EventEmitter {
         if (this.references === 0 && this.watcher) {
             this.watcher.close();
             this.watcher = null;
-            directoryWatchers[this.directory] = null;
+            directoryWatchers.delete(this.directory);
         }
     }
 
@@ -52,30 +56,36 @@ class DirectoryWatcher extends EventEmitter {
 class Watcher {
 
     /**
-     * @param {string} fileOrDirectory
-     * @param {function(string): boolean} [fileFilter] A filter that will receive a filename and needs to return true if this watcher should be invoked.
+     * @param {string|string[]} fileOrDirectory The filename or directory or list of directories to watch
+     * @param {function(string): boolean} [fileFilter] A filter that will receive a filename and needs to return true if this watcher should be invoked. Will be ignored if the first argument is a file.
      * @returns {Watcher}
      */
     constructor(fileOrDirectory, fileFilter = null) {
-        const isDirectory = fs.statSync(fileOrDirectory).isDirectory();
-        let directory = fileOrDirectory;
-        if (!isDirectory) {
-            directory = path.dirname(fileOrDirectory);
+        let directories;
+        if (typeof fileOrDirectory === 'string') {
+            directories = [fileOrDirectory];
+            if (!fs.statSync(fileOrDirectory).isDirectory()) {
+                directories = [path.dirname(fileOrDirectory)];
+                const filename = path.basename(fileOrDirectory);
+                fileFilter = changedFilename => changedFilename === filename;
+            }
+        } else {
+            directories = [...new Set(fileOrDirectory.map(path.normalize))];
         }
-        this.watcher = new DirectoryWatcher(directory);
 
-        if (!isDirectory) {
-            const filename = path.basename(fileOrDirectory);
-            fileFilter = changedFilename => changedFilename === filename;
-        } else if (fileFilter === null) {
+        this.watchers = directories.map(dir => new DirectoryWatcher(dir));
+
+        if (fileFilter === null) {
             fileFilter = () => true;
         }
 
         this.fileFilter = fileFilter;
         this.onChange = this.onChange.bind(this);
         this.onRename = this.onRename.bind(this);
-        this.watcher.on('change', this.onChange);
-        this.watcher.on('rename', this.onRename);
+        this.watchers.forEach(watcher => {
+            watcher.on('change', this.onChange);
+            watcher.on('rename', this.onRename);
+        });
         this.handlers = { change: [], rename: [] };
     }
 
@@ -126,13 +136,12 @@ class Watcher {
      * @api
      */
     close() {
-        if (!(this.watcher instanceof EventEmitter)) {
-            return;
-        }
-        this.watcher.removeListener('change', this.onChange);
-        this.watcher.removeListener('rename', this.onRename);
-        this.watcher.close();
-        this.watcher = null;
+        this.watchers.forEach(watcher => {
+            watcher.removeListener('change', this.onChange);
+            watcher.removeListener('rename', this.onRename);
+            watcher.close();
+        });
+        this.watchers = [];
         this.handlers = { change: [], rename: [] };
     }
 

package/src/WatchesFile.js

@@ -3,9 +3,9 @@ const Watcher = require('./Watcher');
 /**
  * A mixin that provides a file watcher for this.fileName which triggers a method `onChange` on the class, that needs to be implemented.
  *
- * @param {constructor} Base
- * @returns {{new(): {watchFile(): void, close(): void, open(): boolean, stopWatching(): void}, prototype: {watchFile(): void, close(): void, open(): boolean, stopWatching(): void}}}
- * @constructor
+ * @template T
+ * @param {T} Base
+ * @returns {T} An anonymous class that extends Base
  */
 const WatchesFile = Base => class extends Base {
 
@@ -34,12 +34,13 @@ const WatchesFile = Base => class extends Base {
      * @returns {boolean}
      */
     open() {
-        if (this.fd) {
-            return false;
+        if (super.open()) {
+            if (!this.watcher) {
+                this.watchFile();
+            }
+            return true;
         }
-
-        this.watchFile();
-        return super.open();
+        return false;
     }
 
     /**

package/src/metadataUtil.js

@@ -0,0 +1,79 @@
+const crypto = require('crypto');
+
+/**
+ * @param {string} secret The secret to use for calculating further HMACs
+ * @returns {function(string)} A function that calculates the HMAC for a given string
+ */
+const createHmac = secret => string => {
+        const hmac = crypto.createHmac('sha256', secret);
+        hmac.update(string);
+        return hmac.digest('hex');
+    };
+
+/**
+ * @typedef {object|function(object):boolean} Matcher
+ */
+
+/**
+ * @param {object} document The document to check against the matcher.
+ * @param {Matcher} matcher An object of properties and their values that need to match in the object or a function that checks if the document matches.
+ * @returns {boolean} True if the document matches the matcher or false otherwise.
+ */
+function matches(document, matcher) {
+    if (typeof document === 'undefined') return false;
+    if (typeof matcher === 'undefined') return true;
+
+    if (typeof matcher === 'function') return matcher(document);
+
+    for (let prop of Object.getOwnPropertyNames(matcher)) {
+        if (typeof matcher[prop] === 'object') {
+            if (!matches(document[prop], matcher[prop])) {
+                return false;
+            }
+        } else if (typeof matcher[prop] !== 'undefined' && document[prop] !== matcher[prop]) {
+            return false;
+        }
+    }
+    return true;
+}
+
+/**
+ * @param {Matcher} matcher The matcher object or function that should be serialized.
+ * @param {function(string)} hmac A function that calculates a HMAC of the given string.
+ * @returns {{matcher: string|object, hmac?: string}}
+ */
+function buildMetadataForMatcher(matcher, hmac) {
+    if (!matcher) {
+        return undefined;
+    }
+    if (typeof matcher === 'object') {
+        return { matcher };
+    }
+    const matcherString = matcher.toString();
+    return { matcher: matcherString, hmac: hmac(matcherString) };
+}
+
+/**
+ * @param {{matcher: string|object, hmac: string}} matcherMetadata The serialized matcher and its HMAC
+ * @param {function(string)} hmac A function that calculates a HMAC of the given string.
+ * @returns {Matcher} The matcher object or function.
+ */
+function buildMatcherFromMetadata(matcherMetadata, hmac) {
+    let matcher;
+    if (typeof matcherMetadata.matcher === 'object') {
+        matcher = matcherMetadata.matcher;
+    } else {
+        if (matcherMetadata.hmac !== hmac(matcherMetadata.matcher)) {
+            throw new Error('Invalid HMAC for matcher.');
+        }
+        matcher = eval('(' + matcherMetadata.matcher + ')').bind({}); // jshint ignore:line
+    }
+    return matcher;
+}
+
+module.exports = {
+    createHmac,
+    matches,
+    buildMetadataForMatcher,
+    buildMatcherFromMetadata
+};

package/src/util.js

@@ -1,4 +1,5 @@
-const crypto = require('crypto');
+const fs = require('fs');
+const mkdirpSync = require('mkdirp').sync;
 
 /**
  * Assert that actual and expected match or throw an Error with the given message appended by information about expected and actual value.
@@ -27,70 +28,38 @@ function assert(condition, message, ErrorType = Error) {
 }
 
 /**
- * @param {string} secret The secret to use for calculating further HMACs
- * @returns {function(string)} A function that calculates the HMAC for a given string
+ * Return the amount required to align value to the given alignment.
+ * It calculates the difference of the alignment and the modulo of value by alignment.
+ * @param {number} value
+ * @param {number} alignment
+ * @returns {number}
  */
-const createHmac = secret => string => {
-        const hmac = crypto.createHmac('sha256', secret);
-        hmac.update(string);
-        return hmac.digest('hex');
-    };
-
-/**
- * @param {object} document The document to check against the matcher.
- * @param {object|function} matcher An object of properties and their values that need to match in the object or a function that checks if the document matches.
- * @returns {boolean} True if the document matches the matcher or false otherwise.
- */
-function matches(document, matcher) {
-    if (typeof document === 'undefined') return false;
-    if (typeof matcher === 'undefined') return true;
-
-    if (typeof matcher === 'function') return matcher(document);
-
-    for (let prop of Object.getOwnPropertyNames(matcher)) {
-        if (typeof matcher[prop] === 'object') {
-            if (!matches(document[prop], matcher[prop])) {
-                return false;
-            }
-        } else if (document[prop] !== matcher[prop]) {
-            return false;
-        }
-    }
-    return true;
+function alignTo(value, alignment) {
+    return (alignment - (value % alignment)) % alignment;
 }
 
 /**
- * @param {object|function} matcher The matcher object or function that should be serialized.
- * @param {function(string)} hmac A function that calculates a HMAC of the given string.
- * @returns {{matcher: string|object, hmac?: string}}
+ * Method for hashing a string (e.g. a partition name) to a 32-bit unsigned integer.
+ *
+ * @param {string} str
+ * @returns {number}
  */
-function buildMetadataForMatcher(matcher, hmac) {
-    if (!matcher) {
-        return undefined;
-    }
-    if (typeof matcher === 'object') {
-        return { matcher };
+function hash(str) {
+    /* istanbul ignore if */
+    if (str.length === 0) {
+        return 0;
     }
-    const matcherString = matcher.toString();
-    return { matcher: matcherString, hmac: hmac(matcherString) };
-}
+    let hash = 5381,
+        i    = str.length;
 
-/**
- * @param {{matcher: string|object, hmac: string}} matcherMetadata The serialized matcher and it's HMAC
- * @param {function(string)} hmac A function that calculates a HMAC of the given string.
- * @returns {object|function} The matcher object or function.
- */
-function buildMatcherFromMetadata(matcherMetadata, hmac) {
-    let matcher;
-    if (typeof matcherMetadata.matcher === 'object') {
-        matcher = matcherMetadata.matcher;
-    } else {
-        if (matcherMetadata.hmac !== hmac(matcherMetadata.matcher)) {
-            throw new Error('Invalid HMAC for matcher.');
-        }
-        matcher = eval('(' + matcherMetadata.matcher + ')').bind({}); // jshint ignore:line
+    while(i) {
+        hash = ((hash << 5) + hash) ^ str.charCodeAt(--i); // jshint ignore:line
     }
-    return matcher;
+
+    /* JavaScript does bitwise operations (like XOR, above) on 32-bit signed
+     * integers. Since we want the results to be always positive, convert the
+     * signed int to an unsigned by doing an unsigned bitshift. */
+    return hash >>> 0; // jshint ignore:line
 }
 
 /**
@@ -152,30 +121,98 @@ function binarySearch(number, length, get) {
 /**
  * @param {number} index The 1-based index position to wrap around if < 0 and check against the bounds.
  * @param {number} length The length of the index and upper bound.
- * @returns {number|boolean} The wrapped index or false if index out of bounds.
+ * @returns {number} The wrapped index position or -1 if index out of bounds.
  */
 function wrapAndCheck(index, length) {
     if (typeof index !== 'number') {
-        return false;
+        return -1;
     }
 
     if (index < 0) {
         index += length + 1;
     }
     if (index < 1 || index > length) {
-        return false;
+        return -1;
     }
     return index;
 }
 
+/**
+ * Ensure that the given directory exists.
+ * @param {string} dirName
+ * @return {boolean} true if the directory existed already
+ */
+function ensureDirectory(dirName) {
+    if (!fs.existsSync(dirName)) {
+        try {
+            mkdirpSync(dirName);
+        } catch (e) {
+        }
+        return false;
+    }
+    return true;
+}
+
+/**
+ * Perform a k-way merge over multiple streams, invoking a callback for each item in ascending key order.
+ * Each stream object is mutated in place by the `advance` function.
+ *
+ * @param {object[]} streams Array of stream state objects; entries are removed when exhausted.
+ * @param {function(object): number} getKey Returns the current sort key for a stream state.
+ * @param {function(object): boolean} advance Advances the stream to its next item.
+ *   Returns true if the stream has more items within range, false if exhausted.
+ * @param {function(object): void} visit Called for each stream state in merged order.
+ */
+function kWayMerge(streams, getKey, advance, visit) {
+    while (streams.length > 0) {
+        let minIdx = 0;
+        for (let i = 1; i < streams.length; i++) {
+            if (getKey(streams[i]) < getKey(streams[minIdx])) {
+                minIdx = i;
+            }
+        }
+        visit(streams[minIdx]);
+        if (!advance(streams[minIdx])) {
+            streams.splice(minIdx, 1);
+        }
+    }
+}
+
+/**
+ * Scan a directory for files whose names match a regex pattern, calling a callback for each match.
+ * The `onEach` callback receives the first capturing group of the match (`match[1]`), or the full
+ * match (`match[0]`) when no capturing group is defined in the pattern.
+ *
+ * @param {string} directory The directory to scan.
+ * @param {RegExp} regexPattern The pattern to match file names against.
+ * @param {function(string)} onEach Called with the first capturing group (or full match) for each matching file name.
+ * @param {function(Error?)} onDone Called when the scan is complete, or with an error if one occurred.
+ */
+function scanForFiles(directory, regexPattern, onEach, onDone) {
+    fs.readdir(directory, (err, files) => {
+        if (err) {
+            return onDone(err);
+        }
+        let match;
+        for (let file of files) {
+            if ((match = file.match(regexPattern)) !== null) {
+                onEach(match[1] !== undefined ? match[1] : match[0]);
+            }
+        }
+        onDone(null);
+    });
+}
+
+
 module.exports = {
     assert,
     assertEqual,
+    hash,
     wrapAndCheck,
     binarySearch,
-    createHmac,
-    matches,
-    buildMetadataForMatcher,
-    buildMatcherFromMetadata,
-    buildMetadataHeader
+    buildMetadataHeader,
+    alignTo,
+    ensureDirectory,
+    scanForFiles,
+    kWayMerge
 };