jetcheck 1.1.4 → 1.1.6

package/config-example.js

@@ -40,8 +40,10 @@ module.exports = {
             // checker tasks
             tasks: [
                 // { type: "ping", host: "8.8.8.8", count: 2 },
+                // { type: "ping", host: "8.8.8.8", interface: "eth0" },
                 { type: "ping", host: "54.43.5.5" },
                 // { type: "http", url: "https://8.8.8.8" },
+                // { type: "http", url: "https://1.1.1.1", interface: "eth0" },
                 // { type: "http", url: "https://1.1.1.1" },
                 // { type: "http", url: "https://1.2.4.1" },
             ],

package/config-simple.js

@@ -35,7 +35,7 @@ module.exports = {
             init: "DEGRADED",
 
             // test every 15 seconds
-            interval: 15,
+            interval: 5,
 
             // checker tasks
             tasks: [
@@ -54,17 +54,17 @@ module.exports = {
                     content: {
                         from: "alert@tc.be-ys.io",
                         to: "m.vergoz@protonmail.com",
-                        subject: "[FAILED] Dev test",
-                        text: `Hi, the 'Dev test' fails at ${new Date().toLocaleString()}`
+                        // subject: "[FAILED] Dev test",
+                        // text: `Hi, the 'Dev test' fails at ${new Date().toLocaleString()}`
                     }
                 },
 
-                {
-                    type: "ovh.dns.zone.unset",
-                    account: OVH_BeysIO,
-                    zone: "be-ys.io",
-                    config: OVH_BeysIO_DNS
-                },
+                // {
+                //     type: "ovh.dns.zone.unset",
+                //     account: OVH_BeysIO,
+                //     zone: "be-ys.io",
+                //     config: OVH_BeysIO_DNS
+                // },
 
                 { type: "cmd", cmd: `logger "TEST: Disconnected from HTTP"` }
             ],
@@ -77,17 +77,17 @@ module.exports = {
                     content: {
                         from: "alert@tc.be-ys.io",
                         to: "m.vergoz@protonmail.com",
-                        subject: "[RESOLVED] Dev test",
-                        text: `Hi, the 'Dev test' has been resolved at ${new Date().toLocaleString()}`
+                        // subject: "[RESOLVED] Dev test",
+                        // text: `Hi, the 'Dev test' has been resolved at ${new Date().toLocaleString()}`
                     }
                 },
 
-                {
-                    type: "ovh.dns.zone.set",
-                    account: OVH_BeysIO,
-                    zone: "be-ys.io",
-                    config: OVH_BeysIO_DNS
-                },
+                // {
+                //     type: "ovh.dns.zone.set",
+                //     account: OVH_BeysIO,
+                //     zone: "be-ys.io",
+                //     config: OVH_BeysIO_DNS
+                // },
 
                 { type: "cmd", cmd: `logger "TEST: Connected from HTTP"` },
             ],

package/package.json

@@ -1,6 +1,6 @@
 {
  "name": "jetcheck",
- "version": "1.1.4",
+ "version": "1.1.6",
  "description": "Javascript based Network & System checker",
  "main": "index.js",
  "scripts": {
@@ -13,9 +13,9 @@
  "author": "Michael VERGOZ",
  "license": "GPL-3.0",
  "dependencies": {
-  "axios": "^1.7.9",
   "body-parser": "^1.20.3",
   "ejs": "^3.1.10",
+  "elapsed": "^0.0.7",
   "express": "^4.21.2",
   "mkdirp": "^3.0.1",
   "nodemailer": "^6.9.16",

package/services/builtin/cmd.js

@@ -1,5 +1,3 @@
-const axios = require('axios')
-
 module.exports = async function (kernel) {
     kernel.tests.plugins.cmd = {
         toString: function (options) {

package/services/builtin/email.js

@@ -1,4 +1,5 @@
 const NodeMailer = require("nodemailer")
+const Elapsed = require("elapsed")
 
 async function sender(options) {
     const ret = {}
@@ -20,7 +21,55 @@ module.exports = async function (kernel) {
             return (`email(${options.content?.to})`)
         },
         trigger: async function (task, state) {
-            await sender(task)
+            const options = { ...task }
+
+            if (!task.content)
+                task.content = {}
+
+            options.content = { ...task.content }
+
+            // manage auto subject
+            if (!task.content.subject) {
+                if (state.mode === "DEGRADED")
+                    options.content.subject = `[RESOLVED] - ${state.name}`
+                else if (state.mode === "WORKING")
+                    options.content.subject = `[FAILED] - ${state.name}`
+            }
+            else if (typeof task.subject === 'function')
+                options.content.subject = task.subject(options, state)
+
+            // manage email content
+            if (!task.content.text) {
+                const deadTime = state.hasOwnProperty("deadTime") ? state.deadTime : new Date
+                if (state.mode === "DEGRADED")
+                    options.content.text = [
+                        `Hi,`,
+                        '',
+                        `The test '${state.name}' has been resolved at ${new Date().toLocaleString()}`,
+                            `\t- Detection time: ${deadTime.toLocaleString()}`,
+                            `\t- Outage elapsed: ${(new Elapsed(deadTime)).optimal}`,
+                    ].join("\n")
+                else if (state.mode === "WORKING")
+                    options.content.text = [
+                        `Hi,`,
+                        '',
+                        `The test '${state.name}' fails at ${new Date().toLocaleString()}`,
+                    ].join("\n")
+            }
+            else if (typeof task.text === 'function')
+                options.content.text = task.text(options, state)
+
+            if(!options.content.text)
+                options.content.text = ""
+
+            options.content.text = [
+                options.content.text,
+                "",
+                "--",
+                `Jetcheck v${kernel.version}`
+            ].join("\n")
+
+            await sender(options)
         }
     }
     console.log("Loading Email plugin")

package/services/builtin/http.js

@@ -1,24 +1,116 @@
-const axios = require('axios');
+const http = require("http")
+const https = require("https")
+const net = require("net")
+const os = require("os")
+
+const REDIRECT = new Set([301, 302, 303, 307, 308])
+
+function familyOf(entry) {
+    if (entry.family === 6 || entry.family === "IPv6")
+        return 6
+    if (entry.family === 4 || entry.family === "IPv4")
+        return 4
+    return 0
+}
+
+function isLinkLocal(address, family) {
+    if (family === 6)
+        return address.toLowerCase().startsWith("fe80:")
+    if (family === 4)
+        return address.startsWith("169.254.")
+    return false
+}
+
+function sourceAddress(iface, prefer) {
+    const list = os.networkInterfaces()[iface]
+    if (!list || list.length === 0)
+        throw new Error(`Network interface not found "${iface}"`)
+
+    const families = prefer ? [prefer] : [4, 6]
+    for (const family of families) {
+        const matches = list.filter((entry) => familyOf(entry) === family)
+        if (matches.length === 0)
+            continue
+        const usable = matches.filter((entry) => !isLinkLocal(entry.address, family))
+        const pool = usable.length ? usable : matches
+        const picked = pool.find((entry) => !entry.internal) || pool[0]
+        return { address: picked.address, family }
+    }
+    throw new Error(`No usable address on interface "${iface}"`)
+}
+
+function request(url, timeout, source) {
+    return new Promise((resolve, reject) => {
+        let settled = false
+        const fail = (err) => {
+            if (settled)
+                return
+            settled = true
+            reject(err)
+        }
+        const ok = (value) => {
+            if (settled)
+                return
+            settled = true
+            resolve(value)
+        }
+
+        const target = new URL(url)
+        const lib = target.protocol === "https:" ? https : http
+        const options = {
+            protocol: target.protocol,
+            hostname: target.hostname,
+            port: target.port || undefined,
+            path: `${target.pathname}${target.search}`,
+            method: "GET",
+        }
+        if (source) {
+            options.localAddress = source.address
+            options.family = source.family
+        }
+        const req = lib.request(options, (res) => {
+            res.on("error", fail)
+            res.on("data", () => { })
+            res.on("end", () => ok(res))
+        })
+        req.setTimeout(timeout, () => {
+            req.destroy(new Error(`timeout of ${timeout}ms exceeded`))
+        })
+        req.on("error", fail)
+        req.end()
+    })
+}
+
+async function check(url, timeout, source, redirectsLeft = 5) {
+    const res = await request(url, timeout, source)
+    if (REDIRECT.has(res.statusCode) && res.headers.location) {
+        if (redirectsLeft <= 0)
+            throw new Error("Maximum number of redirects exceeded")
+        const next = new URL(res.headers.location, url).toString()
+        return check(next, timeout, source, redirectsLeft - 1)
+    }
+    return null
+}
 
 module.exports = async function (kernel) {
     kernel.tests.plugins.http = {
         toString: function (options) {
-            return (`http(${options.url})`)
+            const via = options.interface ? ` via ${options.interface}` : ""
+            return (`http(${options.url}${via})`)
         },
         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;
+            const timeout = options.timeout ? options.timeout : 5000
+            try {
+                let source = null
+                if (options.interface) {
+                    const hostname = new URL(options.url).hostname
+                    const prefer = net.isIP(hostname)
+                    source = sourceAddress(options.interface, prefer)
                 }
+                return await check(options.url, timeout, source)
+            } catch (error) {
+                return error.message
             }
-            return (await check(options.url))
-
         }
     }
     console.log("Loading HTTP plugin")

package/services/builtin/ovh.js

@@ -1,4 +1,3 @@
-const axios = require('axios')
 const ovh = require('ovh')
 
 

package/services/builtin/ping.js

@@ -1,16 +1,19 @@
-const axios = require('axios');
-
 module.exports = async function (kernel) {
     kernel.tests.plugins.ping = {
         toString: function (options) {
-            return (`ping(${options.host})`)
+            const via = options.interface ? ` via ${options.interface}` : ""
+            return (`ping(${options.host}${via})`)
         },
         run: async function (options, task, state) {
             const count = options.count ? options.count : 3
-            const ret = await kernel.lib.exec(`ping -c ${count} ${options.host}`)
-            if(ret.error > 0)
-                return("Host down")
-            return(null)
+            // macOS binds the socket with -b. Linux accepts the interface name with -I.
+            const bind = options.interface
+                ? (process.platform === "darwin" ? `-b ${options.interface} ` : `-I ${options.interface} `)
+                : ""
+            const ret = await kernel.lib.exec(`ping -c ${count} ${bind}${options.host}`)
+            if (ret.error > 0)
+                return (ret.stderr || "Host down")
+            return (null)
         }
     }
     console.log("Loading PING plugin")

package/services/client.js

@@ -1,57 +1,118 @@
-const axios = require('axios');
+const http = require('http')
 const https = require('https')
-const crypto  = require('crypto')
-const os  = require('os')
+const os = require('os')
 
-class JetcheckAPI {
-    constructor(kernel, account) {
-        this.kernel = kernel
-        this.account = account;
-        this.endpoint = "/api/v1"
+function joinURL(base, path) {
+    return base.replace(/\/+$/, '') + '/' + path.replace(/^\/+/, '')
+}
 
-        // Initializing Axios instance with base configuration
-        this.handler = axios.create({
-            baseURL: account.url, // Replace with the base URL of the API
-            headers: {
-                'Authorization': `${account.token}`, // Example of token-based authentication
-                'User-Agent': `Jetcheck client v${this.kernel.version}`, // Add appKey in headers
-            },
-            timeout: account.timeout || 2000, // Default timeout of 5 seconds
-            validateStatus: () => true,
-            httpsAgent: new https.Agent({
-                rejectUnauthorized: false,
-            }).on('keylog', (line, tlsSocket) => {
-                const cert = tlsSocket.getPeerCertificate(false)
-                if (!cert || !cert.fingerprint256)
-                    return
+function request(method, url, { headers, body, timeout, agent }) {
+    return new Promise((resolve, reject) => {
+        let settled = false
+        const fail = (err) => {
+            if (settled)
+                return
+            settled = true
+            reject(err)
+        }
+        const ok = (value) => {
+            if (settled)
+                return
+            settled = true
+            resolve(value)
+        }
 
-                if (this.account.fingerprint !== cert.fingerprint256) {
-                    console.log(`Bad fingerprint on certificate ${this.account.url} local=${this.account.fingerprint} remote=${cert.fingerprint256}`)
-                    tlsSocket.destroy()
+        const target = new URL(url)
+        const lib = target.protocol === 'https:' ? https : http
+        const payload = body == null ? null : Buffer.from(JSON.stringify(body))
+        const reqHeaders = { ...headers }
+        if (payload) {
+            reqHeaders['Content-Type'] = 'application/json'
+            reqHeaders['Content-Length'] = String(payload.length)
+        }
+
+        const req = lib.request({
+            protocol: target.protocol,
+            hostname: target.hostname,
+            port: target.port || undefined,
+            path: `${target.pathname}${target.search}`,
+            method,
+            headers: reqHeaders,
+            agent: target.protocol === 'https:' ? agent : undefined,
+        }, (res) => {
+            const chunks = []
+            res.on('data', (chunk) => chunks.push(chunk))
+            res.on('error', fail)
+            res.on('end', () => {
+                const raw = Buffer.concat(chunks).toString('utf8')
+                const type = String(res.headers['content-type'] || '')
+                if (!type.includes('application/json')) {
+                    ok({ status: res.statusCode, data: raw })
                     return
                 }
-            }),
-        });
+                try {
+                    ok({ status: res.statusCode, data: raw.length ? JSON.parse(raw) : null })
+                } catch (err) {
+                    fail(err)
+                }
+            })
+        })
+
+        req.setTimeout(timeout, () => {
+            req.destroy(new Error(`timeout of ${timeout}ms exceeded`))
+        })
+        req.on('error', fail)
+        if (payload)
+            req.write(payload)
+        req.end()
+    })
+}
+
+class JetcheckAPI {
+    constructor(kernel, account) {
+        this.kernel = kernel
+        this.account = account
+        this.endpoint = "/api/v1"
+        this.timeout = account.timeout || 2000
+        this.headers = {
+            'Authorization': `${account.token}`,
+            'User-Agent': `Jetcheck client v${this.kernel.version}`,
+            'Accept': 'application/json, text/plain, */*',
+        }
+        this.agent = new https.Agent({
+            rejectUnauthorized: false,
+        }).on('keylog', (line, tlsSocket) => {
+            const cert = tlsSocket.getPeerCertificate(false)
+            if (!cert || !cert.fingerprint256)
+                return
+
+            if (this.account.fingerprint !== cert.fingerprint256) {
+                console.log(`Bad fingerprint on certificate ${this.account.url} local=${this.account.fingerprint} remote=${cert.fingerprint256}`)
+                tlsSocket.destroy()
+            }
+        })
     }
 
-    async get(rcs) {
-        // console.log(`GET ${this.account.url}${this.endpoint}${rcs}`);
+    async call(method, rcs, data) {
         try {
-            const response = await this.handler.get(`${this.endpoint}${rcs}`);
-            return { err: null, data: response.data };
+            const response = await request(method, joinURL(this.account.url, `${this.endpoint}${rcs}`), {
+                headers: this.headers,
+                body: data,
+                timeout: this.timeout,
+                agent: this.agent,
+            })
+            return { err: null, data: response.data }
         } catch (err) {
-            return { err: err.message, data: null };
+            return { err: err.message, data: null }
         }
     }
 
+    async get(rcs) {
+        return this.call('GET', rcs)
+    }
+
     async post(rcs, data) {
-        // console.log(`POST ${this.account.url}${this.endpoint}${rcs}`);
-        try {
-            const response = await this.handler.post(`${this.endpoint}${rcs}`, data);
-            return { err: null, data: response.data };
-        } catch (err) {
-            return { err: err.message, data: null };
-        }
+        return this.call('POST', rcs, data)
     }
 }
 

package/services/tests.js

@@ -90,12 +90,13 @@ module.exports = async function (kernel) {
                 async function pop() {
                     const task = state.current.pop()
                     if (!task) {
-                        if(state.succeed.length === 0 && state.failed.length === 0) {
+                        if (state.succeed.length === 0 && state.failed.length === 0) {
                             // do nothing
                         }
                         else if (state.succeed.length === 0) {
                             if (state.mode === "WORKING") {
                                 console.log(`System "${testName}" is degraded`)
+                                state.deadTime = new Date
                                 if (test.failed) {
                                     for (var item of test.failed) {
                                         const module = kernel.tests.plugins[item.type]
@@ -109,6 +110,7 @@ module.exports = async function (kernel) {
                         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]
@@ -116,6 +118,7 @@ module.exports = async function (kernel) {
                                             await module.trigger(item, state)
                                     }
                                 }
+                                delete state.deadTime
                             }
                             state.mode = "WORKING"
                         }
@@ -137,7 +140,7 @@ module.exports = async function (kernel) {
                             state.succeed.push(task)
                         else
                             state.failed.push({ ...task, error })
-                    } catch(e) {
+                    } catch (e) {
                         console.log(`Test "${testName}" failed: ${e.message}`)
                     }