@smartface/library-manager/libraryManager.js

#!/usr/bin/env node

const execSync = require('child_process').execSync;
const args = require('minimist')(process.argv.slice(2));
const chokidar = require('chokidar');
const RawIPC = require('node-ipc').IPC;
const ipc = new RawIPC();
const fakeIpc = new RawIPC();
const library = require("./src/library");
const BRACKET_END = "$(B_R-A_C-K_E-T)";

var watcherEnabled = true;
var readCounter = 0;
var writeCounter = 0;

ipc.config.id = 'sfLibraryManager';
ipc.config.retry = 5000;
ipc.config.encoding = "binary";
ipc.config.maxConnections = 15;
fakeIpc.config.port = 8000;
ipc.config.logger = function(a) { args.verbose && console.log(a) };
fakeIpc.config.logger = function() {};
var sockets = [];
var _libraryFolder;

process.on("uncaughtException", logError);
process.on('unhandledRejection', logError);

if (args.restart) {
    try {
        execSync(`fuser -k ${ipc.config.port}/tcp`);
    }
    catch (ex) {
        // do nothing; process is not running; everything is OK
    }
}

function logError(reason) {
    console.error("├─── ! ☠️ ! ──────── LibraryManager ───── Unhandled Error ─────────────────────────┤\n" +
        reason.stack ? reason.stack.toString("utf8") : reason.toString("utf8"));
}

function initLibraryTask(data, cb) {
    library.createLibDirFile(_libraryFolder, data.initialLibraryData, e => {
        e && console.error(e);
        cb && cb(e);
        watch(_libraryFolder);
    });
}

function watch(libraryFolder) {
    var watcher = chokidar.watch(`${libraryFolder}/*.!(pgx)cpx`, {
        ignoreInitial: true
    });
    watcher.on("all", (e, filename) => {
        if (!watcherEnabled)
            return;
        ++readCounter;
        setTimeout(_ => {
            if (--readCounter !== 0)
                return;
            console.log("Watcher ..> ", e, " . ", filename);
            readTask((e, res) => {
                sockets.forEach(s => {
                    ipc.server.emit(
                        s,
                        e ? 'error' : 'read',
                        e ? e.toString() : res
                    );
                });
            });
        }, 300);
    });
}

function readTask(cb) {
    cb = typeof cb === "function" ? cb : function() {};
    library.read(_libraryFolder, function(err, comps) {
        if (err) {
            console.error(err);
            cb(err);
        }
        else {
            return cb(null, JSON.stringify(comps));
        }
    });
}

function writeTask(data, cb) {
    cb = typeof cb === "function" ? cb : function() {};
    try {
        var componentsWithChildren = JSON.parse(data);
    }
    catch (e) {
        console.error(e);
        return cb(e);
    }
    ++writeCounter;
    watcherEnabled = false;
    library.saveComponents(_libraryFolder, componentsWithChildren, err => {
        setTimeout(_ => {
            --writeCounter;
            if (writeCounter === 0)
                watcherEnabled = true;
        }, 1000);
        if (err) {
            console.error(err);
            cb(err);
        }
    });
}

ipc.serveNet(); // with port;

ipc.serve(
    "/tmp/app.sfLibraryManager",
    function() {
        console.log("Server initializon...");
        ipc.server.on(
            'writeTask',
            function(data, socket) {
                console.log("WriteTask", data.length);
                writeTask(data);
            }
        );

        ipc.server.on(
            'readTask',
            function(data, socket) {
                console.log("ReadTask ", data.name);
                _libraryFolder = _libraryFolder || data.libraryFolder;
                socket.name = data && data.name;
                readTask((e, res) => {
                    ipc.server.emit(
                        socket,
                        'read',
                        res
                    );
                });
            }
        );

        ipc.server.on(
            'init',
            function(data, socket) {
                console.log("Init ", data.name);
                socket.name = data && data.name;
                _libraryFolder = data.libraryFolder;
                sockets.push(socket);
                initLibraryTask(data, e => {
                    readTask((e, res) => {
                        ipc.server.emit(
                            socket,
                            'read',
                            res
                        );
                    });
                });
            }
        );

        ipc.server.on(
            'socket.disconnected',
            function(socket) {
                sockets = sockets.filter(s => s !== socket);
                console.log('DISCONNECTED ', socket.name);
            }
        );
    }
);

ipc.server.on(
    'error',
    function(err) {
        console.log('Got an ERROR!', err);
    }
);

ipc.server.start();

fakeIpc.serveNet();
fakeIpc.server.start();