jetcheck 1.0.1

package/bin/index.js

@@ -0,0 +1,20 @@
+#!/usr/bin/env node
+
+const path = require("path")
+const sc = require('subcommander');
+const os = require('os');
+const fs = require('fs');
+const crypto = require('crypto');
+const netcheck = require("../index")
+
+// Early loading configuration file
+const configFile = path.resolve(
+    process.cwd(),
+    process.env.CONFIG || `${os.homedir()}/.netcheck/config.js`
+)
+require("./systemd")(netcheck, sc, configFile)
+require("./run")(netcheck, sc, configFile)
+
+sc.parse()
+
+

package/bin/run.js

@@ -0,0 +1,25 @@
+
+
+const fs = require('fs')
+const path = require("path")
+
+module.exports = (netcheck, sc, configFile) => {
+    sc.command('run', {
+        desc: 'Run the monitoring',
+        callback: async function (options) {
+            const kernel = new netcheck({ configFile })
+            await kernel.start()
+        }
+    })
+
+    sc.command('test', {
+        desc: 'Run the monitoring',
+        callback: async function (options) {
+            const kernel = new netcheck({ headless: true, configFile })
+            await kernel.start()
+        }
+
+    })
+}
+
+

package/bin/systemd.conf

@@ -0,0 +1,15 @@
+[Unit]
+Description=Netcheck
+After=network-online.target
+
+[Service]
+Type=simple
+WorkingDirectory=<%- cwd %>
+ExecStart=<%- runCmd %>
+Restart=always
+TimeoutStopSec=300
+RestartSec=5s
+Environment="<%- config %>"
+
+[Install]
+WantedBy=multi-user.target

package/bin/systemd.js

@@ -0,0 +1,63 @@
+
+
+const fs = require('fs')
+const path = require("path")
+const ejs = require("ejs")
+
+module.exports = (netcheck, sc, configFile) => {
+
+    const systemd = sc.command('systemd', {
+        desc: 'Linux systemd service management'
+    })
+
+    systemd.command('install', {
+        desc: 'Run the monitoring',
+        callback: async function (options) {
+            var installed = false
+            try {
+                fs.statSync("/etc/systemd/system/netcheck.service")
+                installed = true
+            } catch (e) { }
+
+            if (installed === true) {
+                console.log("Netcheck is already installed")
+                process.exit(-1)
+            }
+
+            const kernel = new netcheck({ configFile })
+
+            const runCmd = `${process.argv[0]} ${process.argv[1]} run`
+            const content = fs.readFileSync(__dirname + "/systemd.conf").toString()
+            const render = ejs.render(content, { configFile, runCmd, cwd: process.cwd(), config: `CONFIG=${configFile}` })
+            fs.writeFileSync("/etc/systemd/system/netcheck.service", render)
+
+            await kernel.lib.exec("systemctl daemon-reload", false)
+            await kernel.lib.exec("systemctl enable netcheck", false)
+            console.log("To start type: systemctl start netcheck")
+        }
+    })
+
+    systemd.command('deinstall', {
+        desc: 'Run the monitoring',
+        callback: async function (options) {
+            var installed = false
+            try {
+                fs.statSync("/etc/systemd/system/netcheck.service")
+                installed = true
+            } catch (e) { }
+
+            if (installed === false) {
+                console.log("Netcheck is not installed")
+                process.exit(-1)
+            }
+            const kernel = new netcheck({ configFile })
+
+            await kernel.lib.exec("systemctl stop netcheck", false)
+            await kernel.lib.exec("systemctl disable netcheck", false)
+            fs.unlinkSync("/etc/systemd/system/netcheck.service")
+            await kernel.lib.exec("systemctl daemon-reload", false)
+            console.log("Netcheck deinstalled")
+        }
+    })
+}
+

package/config-example.js

@@ -0,0 +1,31 @@
+module.exports = {
+    tests: {
+        myCheck: {
+            // start from degraded mode
+            init: "DEGRADED",
+
+            // test every 15 seconds
+            interval: 15,
+
+            // checker tasks
+            tasks: [
+                { type: "ping", host: "8.8.8.8", count: 2 },
+                // { type: "ping", host: "54.43.5.5" },
+                { type: "http", url: "https://8.8.8.8" },
+                { type: "http", url: "https://1.1.1.1" },
+                { type: "http", url: "https://1.2.4.1" },
+            ],
+
+            // when system fails
+            failed: [
+                { type: "cmd", cmd: `logger "TEST: Disconnected from HTTP"` }
+            ],
+
+            // when system succeed
+            succeed: [
+                { type: "cmd", cmd: `logger "TEST: Connected from HTTP"` },
+                { type: "cmd", cmd: `logger "TEST: secondary command"` }
+            ],
+        }
+    }
+}

package/config-wan.js

@@ -0,0 +1,21 @@
+module.exports = {
+    tests: {
+        wan: {
+            init: "WORKING",
+            interval: 5,
+            tasks: [
+                { type: "ping", host: "8.8.8.8", count: 3 },
+                { type: "http", url: "https://8.8.8.8" },
+                { type: "http", url: "https://1.1.1.1" },
+            ],
+
+            failed: [
+                { type: "cmd", cmd: `systemctl stop frr` }
+            ],
+            succeed: [
+                { type: "cmd", cmd: `systemctl start frr` },
+            ],
+        }
+    }
+
+}

package/index.js

@@ -0,0 +1,72 @@
+const path = require("path")
+
+// internal requires
+const pack = require("./package.json")
+const aevent = require("./lib/aevent")
+
+class netcheck {
+    constructor(options) {
+        this.options = options || {}
+        this.events = new aevent()
+        this.lib = require("./lib")
+        this.packages = {}
+
+        this.packageInfo(pack, ["service"])
+    }
+
+    packageInfo(pkg, log) {
+        var buffer = [`version=${pkg.version} -`]
+        for (var key in pkg.dependencies)
+            buffer.push(`${key}=${pkg.dependencies[key]}`)
+        this.packages[pkg.name] = pkg
+    }
+
+    async sleep(ms) {
+        return new Promise(resolve => setTimeout(resolve, ms));
+    }
+
+    async start(overwrite) {
+        this.version = pack.version
+
+        // load configuration
+        if (this.options.configFile) {
+            this.configFile = path.resolve(process.cwd(), this.options.configFile);
+            try {
+                this.config = require(this.configFile)
+            } catch (e) {
+                console.log(`Can not read configuration ${this.configFile}`)
+                process.exit(-1)
+            }
+        }
+        else
+            this.config = {}
+
+        // overwrite feature
+        if (overwrite)
+            this.config = { ...this.config, ...overwrite }
+
+        if (!Array.isArray(this.config.modules))
+            this.config.modules = []
+
+        // load basic services
+        await (require("./services/tests"))(this)
+
+        // load modules
+        if (this.config.modules) {
+            for (var module of this.config.modules) {
+                await require(module)(this)
+            }
+        }
+
+        await this.events.emit("kernel.init", this)
+    }
+
+    async stop() {
+
+    }
+
+}
+
+module.exports = netcheck
+
+

package/lib/aevent.js

@@ -0,0 +1,18 @@
+class asEventEmitter {
+  constructor() {
+    this._acall = {}
+  }
+
+  async emit(ev, ...argv) {
+    if (!this._acall[ev]) return;
+    const list = this._acall[ev];
+    for (let call of list) await call(...argv);
+  }
+
+  on(ev, cb) {
+    if (!this._acall[ev]) this._acall[ev] = []
+    this._acall[ev].push(cb)
+  }
+}
+
+module.exports = asEventEmitter;

package/lib/exec.js

@@ -0,0 +1,61 @@
+const { spawn } = require('child_process');
+
+async function detachedExec(cmd, detached = true) {
+    return new Promise((resolve) => {
+        // Split the command into the executable and its arguments
+        const [command, ...args] = cmd.split(' ')
+
+        // Launch the detached process
+        const child = spawn(command, args, {
+            detached, // Detach the child process from the parent
+            stdio: ['ignore', 'pipe', 'pipe'], // Ignore stdin and stderr, capture stdout
+        })
+
+        let stdout = ''
+        let stderr = ''
+
+        // Capture stdout
+        child.stdout.on('data', (data) => {
+            stdout += data.toString();
+        })
+
+        child.stderr.on('data', (data) => {
+            stderr += data.toString();
+        })
+
+        // Handle process completion
+        child.on('close', (code) => {
+            resolve({
+                stdout: stdout.trim(),
+                stderr: stderr.trim(),
+                error: code, // If code is 0, no error; otherwise, return the error code
+            })
+        })
+
+        // Handle process errors
+        child.on('error', (err) => {
+            resolve({
+                stdout: '',
+                stderr: stderr.trim(),
+                error: err, // Default error code for execution failure
+            })
+        })
+
+        // Actually detach the process
+        if (detached === true)
+            child.unref()
+    })
+}
+
+module.exports = detachedExec
+
+// async function init() {
+//     async function para() {
+//         const ret = await detachedExec("ping -c 5 9.9.9.9")
+//         console.log(ret)
+//     }
+//     para()
+//     para()
+// }
+
+// init()

package/lib/index.js

@@ -0,0 +1,4 @@
+module.exports = {
+    exec: require("./exec"),
+    aevent: require("./aevent"),
+}

package/package.json

@@ -0,0 +1,24 @@
+{
+ "name": "jetcheck",
+ "version": "1.0.1",
+ "description": "Javascript based Network & System checker",
+ "main": "index.js",
+ "scripts": {
+  "test": "echo \"Error: no test specified\" && exit 1"
+ },
+ "bin": {
+  "jetcheck": "bin/index.js"
+ },
+ "repository": "https://github.com/mykiimike/jetcheck",
+ "author": "Michael VERGOZ",
+ "license": "GPL-3.0",
+ "dependencies": {
+  "axios": "^1.7.9",
+  "ejs": "^3.1.10",
+  "mkdirp": "^3.0.1",
+  "subcommander": "^1.0.0"
+ },
+ "devDependencies": {
+  "semver": "^7.6.3"
+ }
+}

package/services/builtin/cmd.js

@@ -0,0 +1,13 @@
+const axios = require('axios')
+
+module.exports = async function (kernel) {
+    kernel.tests.plugins.cmd = {
+        toString: function (options) {
+            return (`cmd(${options.cmd})`)
+        },
+        trigger: async function (task, state) {
+            await kernel.lib.exec(task.cmd)
+        }
+    }
+    console.log("Loading CMD plugin")
+}

package/services/builtin/http.js

@@ -0,0 +1,25 @@
+const axios = require('axios');
+
+module.exports = async function (kernel) {
+    kernel.tests.plugins.http = {
+        toString: function (options) {
+            return (`http(${options.url})`)
+        },
+        run: async function (options, task, state) {
+            async function check(url) {
+                try {
+                    await axios.get(url, {
+                        timeout: options.timeout ? options.timeout : 5000,
+                        validateStatus: () => true,
+                    });
+                    return null;
+                } catch (error) {
+                    return error.message;
+                }
+            }
+            return (await check(options.url))
+
+        }
+    }
+    console.log("Loading HTTP plugin")
+}

package/services/builtin/ping.js

@@ -0,0 +1,17 @@
+const axios = require('axios');
+
+module.exports = async function (kernel) {
+    kernel.tests.plugins.ping = {
+        toString: function (options) {
+            return (`ping(${options.host})`)
+        },
+        run: async function (options, task, state) {
+            const count = options.count ? options.count : 5
+            const ret = await kernel.lib.exec(`ping -c ${count} ${options.host}`)
+            if(ret.error > 0)
+                return("Host down")
+            return(null)
+        }
+    }
+    console.log("Loading PING plugin")
+}

package/services/tests.js

@@ -0,0 +1,146 @@
+const path = require("path")
+const { start } = require("repl")
+
+module.exports = async function (kernel) {
+    kernel.tests = {
+        plugins: {},
+        states: {}
+    }
+
+    // tester
+    kernel.config.modules.push(__dirname + "/builtin/http.js")
+    kernel.config.modules.push(__dirname + "/builtin/ping.js")
+
+    // triggers
+    kernel.config.modules.push(__dirname + "/builtin/cmd.js")
+
+    kernel.events.on("kernel.init", async function () {
+
+        if (kernel.options.headless === true)
+            return
+
+        
+
+        // prepare initial states
+        for (var testName in kernel.config.tests) {
+            const test = kernel.config.tests[testName]
+
+            if (!test.interval)
+                test.interval = 5
+            test.interval = test.interval * 1000
+
+            kernel.tests.states[testName] = {
+                status: "INIT",
+                mode: "INIT",
+                startTime: Date.now(),
+                lastTime: 0,
+                original: [],
+                lastSucceed: [],
+                lastFailed: [],
+                succeed: [],
+                failed: []
+            }
+            const state = kernel.tests.states[testName]
+
+            if(test.init.toLowerCase() === "working")
+                state.mode = "WORKING"
+            else if(test.init.toLowerCase() === "degraded")
+                state.mode = "DEGRADED"
+            else
+                state.mode = "WORKING"
+
+            // prepare test pipelines
+            for (var task of test.tasks) {
+                if (!kernel.tests.plugins[task.type]) {
+                    console.log(`Test plugin not found "${task.type}"`)
+                    continue
+                }
+                if (!kernel.tests.plugins[task.type].run) {
+                    console.log(`Plugin "${task.type}" cannot run test`)
+                    continue
+                }
+                state.original.push(task)
+            }
+
+            console.log(`Test "${testName}" loaded`)
+
+        }
+
+        async function check() {
+            for (let testName in kernel.config.tests) {
+                const test = kernel.config.tests[testName]
+                const state = kernel.tests.states[testName]
+
+                // console.log(`name=${testName} status=${state.status} mode=${state.mode} elapsed=${test.interval - (Date.now() - state.startTime)}ms succeed=${state.lastSucceed.length} failed=${state.lastFailed.length}`)
+
+                if (state.status === "RUNNING")
+                    continue;
+
+                if (Date.now() - state.lastTime < test.interval)
+                    continue;
+
+                state.startTime = Date.now()
+                state.status = "RUNNING"
+                state.current = [...state.original]
+                state.lastSucceed = state.succeed
+                state.lastFailed = state.failed
+                state.succeed = []
+                state.failed = []
+
+                async function pop() {
+                    const task = state.current.pop()
+                    if (!task) {
+                            
+                        if(state.succeed.length === 0) {
+                            if(state.mode === "WORKING") {
+                                console.log(`System "${testName}" is degraded`)
+                                if(test.failed) {
+                                    for(var item of test.failed) {
+                                        const module = kernel.tests.plugins[item.type]
+                                        if(module && module.trigger) 
+                                            await module.trigger(item, state)
+                                    }
+                                }
+                            } 
+                            state.mode = "DEGRADED"
+                        }
+                        else {
+                            if(state.mode === "DEGRADED") {
+                                console.log(`System ${testName} is restored`)
+                                if(test.succeed) {
+                                    for(var item of test.succeed) {
+                                        const module = kernel.tests.plugins[item.type]
+                                        if(module && module.trigger) 
+                                            await module.trigger(item, state)
+                                    }
+                                }
+                            } 
+                            state.mode = "WORKING"
+                        }
+
+                        state.lastSucceed = state.succeed
+                        state.lastFailed = state.failed
+                        
+                        state.startTime = Date.now()
+                        state.lastTime = Date.now()
+                        state.status = "PENDING"
+                        return
+                    }
+
+                    const module = kernel.tests.plugins[task.type]
+                    // console.log(`Executing ${testName} > ${module.toString(task)}`)
+                    const error = await module.run(task, test, state)
+                    if (!error)
+                        state.succeed.push(task)
+                    else
+                        state.failed.push({ ...task, error })
+
+                    setTimeout(pop, 10)
+                }
+                setTimeout(pop, 10)
+            }
+            setTimeout(check, 1000)
+        }
+        check()
+    })
+}

package/version.js

@@ -0,0 +1,34 @@
+const fs = require("fs")
+const util = require('util')
+const semver = require('semver');
+const exec = util.promisify(require('child_process').exec)
+
+const gitRepo = "./"
+
+const isoDate = new Date().toISOString().slice(0, 10);
+
+async function safeExec(cmd, ignore) {
+    console.log(cmd)
+    try {
+        const ret = await exec(cmd)
+        if (ret.stderr.length > 0) return ({ error: ret.stderr.split("\n")[0] })
+        if (ret.stdout.length === 0) return ({})
+        return ({ data: JSON.parse(ret.stdout) })
+    } catch (e) {
+        if (ignore !== true) return ({ error: e.message })
+        return ({})
+    }
+}
+
+(async () => {
+    const packageData = require(gitRepo + '/package.json');
+    packageData.version = semver.inc(packageData.version, 'patch');
+    fs.writeFileSync(gitRepo + '/package.json', JSON.stringify(packageData, null, " "));
+
+    await safeExec(`cd ${gitRepo} && git commit -m "Release ${packageData.version}" -a`)
+
+    await safeExec(`cd ${gitRepo} && git push`)
+    await safeExec(`cd ${gitRepo} && git tag ${packageData.version}`)
+    await safeExec(`cd ${gitRepo} && git push --tags`)
+    await safeExec(`cd ${gitRepo} && npm publish`)
+})();