jetcheck 1.1.5 → 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/package.json

@@ -1,6 +1,6 @@
 {
  "name": "jetcheck",
- "version": "1.1.5",
+ "version": "1.1.6",
  "description": "Javascript based Network & System checker",
  "main": "index.js",
  "scripts": {
@@ -13,7 +13,6 @@
  "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",

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/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)
     }
 }