updated for use uptime from minataur

Author: olton

.gitignore

@@ -21,3 +21,4 @@ package-lock.json
 *.http
 *.key
 *.crt
+.parcel-cache

babel.config.json

@@ -1,15 +1,6 @@
 {
     "presets": [
-        [
-            "@babel/preset-env",
-            {
-                "targets": {
-                    "esmodules": true
-                }
-            }
-        ]
     ],
     "plugins": [
-        "@babel/plugin-proposal-class-properties"
     ]
 }

client/index.html

@@ -437,8 +437,6 @@
         </div>
     </section>
 
-    <script src="vendor/metro4/js/metro.js"></script>
-    <script src="vendor/chart/chart.js"></script>
-    <script src="js/app.js"></script>
+    <script type="module" src="js/app.js"></script>
 </body>
 </html>

client/js/app.js

@@ -1,4 +1,4 @@
-import 'regenerator-runtime/runtime' // this required for Parcel
+//import 'regenerator-runtime/runtime' // this required for Parcel
 
 import "../vendor/metro4/css/metro-all.css"
 import "../css/index.less"

client/package.json

@@ -1,22 +1,19 @@
 {
     "name": "@olton/mina-monitor-client",
-    "version": "2.1.2",
+    "version": "2.2.0",
     "license": "MIT",
     "scripts": {
-        "client": "shx rm -rf output/* && parcel serve --target browser --out-dir output index.html -p 2222",
-        "start": "shx rm -rf output/* && parcel serve --target browser --out-dir output index.html -p 2222 --open"
+        "client": "shx rm -rf output/* && npm run copy && parcel serve --dist-dir output index.html -p 2222",
+        "start": "shx rm -rf output/* && npm run copy && parcel serve --dist-dir output index.html -p 2222 --open",
+        "copy": "copyfiles -f config.json output"
     },
     "devDependencies": {
         "less": "^4.1.1",
-        "parcel-bundler": "^1.12.5",
-        "parcel-plugin-static-files-copy": "^2.6.0",
+        "parcel": "latest",
+        "@parcel/transformer-less": "^2.5.0",
+        "copyfiles": "^2.4.1",
         "shx": "^0.3.3"
     },
-    "staticFiles": {
-        "staticPath": [
-            "config.json"
-        ]
-    },
     "browserslist": [
         "last 1 Chrome versions",
         "last 1 Firefox versions",

package.json

@@ -1,21 +1,23 @@
 {
   "name": "@olton/mina-monitor",
-  "version": "2.1.2",
+  "version": "2.2.0",
   "license": "MIT",
-  "main": "server/index.js",
   "scripts": {
-    "serve": "shx rm -rf output/* && parcel serve --open --target browser --out-dir output client/index.html -p 2222",
-    "prebuild": "shx rm -rf dist/*",
-    "build": "parcel build --out-dir dist --public-url . --no-source-maps client/index.html",
-    "start": "npm run serve",
+    "start": "shx rm -rf client/output/* && npm run copy && parcel serve --open --dist-dir client/output client/index.html -p 2222",
+    "serve": "parcel serve --open --dist-dir client/output client/index.html -p 2222",
+    "prebuild": "shx rm -rf client/dist/* && npm run copy",
+    "clear": "shx rm -rf client/dist/* client/output/* ",
+    "build": "parcel build --dist-dir client/dist --public-url . --no-source-maps client/index.html",
     "client": "npm run serve",
     "server": "nodemon server/index.js",
-    "test": "jest"
+    "copy": "copyfiles -f client/config.json client/output"
   },
   "devDependencies": {
+    "@babel/core": "^7.17.10",
+    "@parcel/transformer-less": "^2.5.0",
+    "copyfiles": "^2.4.1",
     "less": "^4.1.1",
-    "parcel-bundler": "^1.12.5",
-    "parcel-plugin-static-files-copy": "^2.6.0",
+    "parcel": "latest",
     "shx": "^0.3.3"
   },
   "dependencies": {
@@ -24,11 +26,6 @@
     "systeminformation": "^5.7.7",
     "ws": "^5.2.3"
   },
-  "staticFiles": {
-    "staticPath": [
-      "client/config.json"
-    ]
-  },
   "browserslist": [
     "last 1 Chrome versions",
     "last 1 Firefox versions",

server/helpers/logs.js

@@ -1,9 +1,13 @@
 const {timestamp} = require("./timestamp")
 
 const print = (m) => console.log(m)
-const logging = (m, error = false) => console[error ? "error" : "log"](timestamp()+" "+m)
+const logging = (m, error = false, ...rest) => console[error ? "error" : "log"](timestamp()+" "+m, ...rest)
+const log = (m, ...rest) => console["log"](timestamp()+" "+m, ...rest)
+const error = (m, ...rest) => console["error"](timestamp()+" "+m, ...rest)
 
 module.exports = {
     print,
-    logging
+    logging,
+    error,
+    log
 }

server/index.js

@@ -13,7 +13,7 @@ const {processWinningBlocks, processBlockchainSummary, processBlockchainLatestBl
 const {processAlerter} = require("./modules/alerter")
 const {processBalance} = require("./modules/balance")
 const {processHello} = require("./modules/hello")
-const {processUptime} = require("./modules/uptime")
+const {processUptime, processUptime2} = require("./modules/uptime")
 const {processDelegations} = require("./modules/delegations")
 const {processPriceInfo, processPriceSend} = require("./modules/price")
 const {processSnarkWorkerController} = require("./modules/snark-worker")
@@ -23,12 +23,13 @@ const {SYNC_STATE_UNKNOWN} = require("./helpers/consts")
 const {processConsensus} = require("./modules/consensus")
 const {processBlockchain} = require("./modules/blockchain")
 const {processBlockSpeed} = require("./modules/speed")
-const {logging} = require("./helpers/logs")
+const {logging, log, error} = require("./helpers/logs")
 const {welcomeHtml} = require("./helpers/welcome")
 const {processCompare} = require("./modules/comparer")
 const packageJson = require("./package.json")
 const {processConfigWatcher} = require("./helpers/watcher");
 const {processGetMinaVersion} = require("./helpers/shell");
+const {parseTime} = require("./helpers/parsers");
 
 const version = packageJson.version
 const configPathLinux = "/etc/mina-monitor/config.json"
@@ -144,6 +145,75 @@ if (useHttps) {
 
 const wss = new WebSocket.Server({ server })
 
+const {host: minataurHost = 'minataur.net:443', secure: minataurSecure = true} = config.minataur
+
+const isOpen = (ws) => ws && ws.readyState === ws.OPEN
+
+const request = (ws, channel, data) => {
+    if (isOpen(ws)) {
+        ws.send(JSON.stringify({
+            channel,
+            data
+        }))
+    }
+}
+
+const connectToMinataur = () => {
+    const ws = new WebSocket(`${minataurSecure ? 'wss' : 'ws'}://${minataurHost}`)
+
+    ws.onerror = e => {
+        error('Socket from Minataur encountered error: ', e.message, 'Closing socket');
+        ws.close();
+    }
+
+    ws.onclose = e => {
+        log('Socket from Minataur is closed. Reconnect will be attempted in 1 second.', e.reason);
+        setTimeout(connectToMinataur, 1000)
+    }
+
+    ws.onopen = e => {
+        log('Connected to Minataur!')
+    }
+
+    ws.onmessage = msg => {
+        const message = JSON.parse(msg.data)
+        if (!message.channel) return
+        const {channel, data} = message
+
+        let uptimeUpdateInterval = parseTime(config.uptimeUpdateInterval || '5m')
+
+        if (uptimeUpdateInterval < parseTime("5m")) {
+            uptimeUpdateInterval = parseTime("5m")
+        }
+
+        const requestUptime = (addr = config.publicKeyDelegators || config.publicKey) => {
+            request(ws, "address_uptime_full", addr)
+        }
+
+        switch (channel){
+            case 'welcome': {
+                log("Welcome to Minataur!")
+                requestUptime()
+                break
+            }
+            case 'address_uptime_full': {
+                try {
+                    processUptime(data)
+                }
+                catch (e) {
+                    error(e.message)
+                }
+                finally {
+                    setTimeout(requestUptime, uptimeUpdateInterval)
+                }
+                break;
+            }
+        }
+    }
+}
+
+connectToMinataur()
+
 server.listen(+SERVER_PORT, SERVER_HOST, () => {
     logging(`Mina Monitor Server running on ${useHttps ? 'https' : 'http'}://${SERVER_HOST}:${SERVER_PORT}`)
 })
@@ -198,7 +268,6 @@ setImmediate( processCpuTemp )
 setImmediate( processNetStat )
 setImmediate( processNetConn )
 setImmediate( processPriceInfo )
-setImmediate( processUptime )
 setImmediate( processDelegations )
 setImmediate( processJournal )
 setImmediate( processHello )

server/modules/uptime.js

@@ -1,54 +1,36 @@
-const fetch = require("node-fetch")
 const {sendMessage} = require("../helpers/messangers");
-const {parseTime} = require("../helpers/parsers");
-
-const getUptime = async (key) => {
-    if (!key) return null
-
-    const link = `https://minastake.com/uptime/uptime2.php?publicKey=${key}`
-    let data
-
-    try {
-        data = await fetch(link)
-        return data.ok ? data.json() : null
-    } catch (e) {
-        return null
-    }
-}
-
-const processUptime = async () => {
-    const minInterval = parseTime('5m')
-    let {uptimeUpdateInterval = minInterval} = config
-
-    if (uptimeUpdateInterval < minInterval) {
-        uptimeUpdateInterval = minInterval
-    }
+const {error} = require("../helpers/logs");
 
+const processUptime = (data) => {
     try {
-        const {publicKeyDelegators} = globalThis.config
-        const uptime = await getUptime(publicKeyDelegators)
+        const {uptime, line} = data
 
         if (uptime && uptime.score) {
-            let message = '', scoreChanged = false, positionChanged = false, rateChanged = false
-            let {position, score, rate, group, positions} = uptime
+            let message = '', scoreChanged = false, positionChanged = false, rateChanged = false, rangeChanged = false
+            let {position, score, rate, range} = uptime
 
-            positions = positions.map( v => +v ).sort( (a, b) => a - b)
 
             if (!cache.uptime) {
-                message = `Your current uptime score is \`${uptime.score}\` with rate \`${uptime.rate}%\`, and at the \`${uptime.position}\` place in range ${positions[0]}...${positions[positions.length - 1]}.`
+                message = `Your current uptime score is \`${uptime.score}\` with rate \`${uptime.rate}%\`, and at the \`${uptime.position}\` place in range ${range.min}...${range.max}.`
             } else {
-                let {position: cachedPosition, score: cachedScore, rate: cachedRate, group: cachedGroup, positions: cachedPositions} = cache.uptime
+                let {position: cachedPosition, score: cachedScore, rate: cachedRate, range: cachedRange} = cache.uptime.uptime
 
                 scoreChanged = +(cachedScore) !== +(score)
                 rateChanged = +(cachedRate) !== +(rate)
-                positionChanged = positions[0] !== cachedPositions[0] || positions[positions.length - 1] !== cachedPositions[cachedPositions.length - 1]
+                positionChanged = +(cachedPosition) !== +(position)
+                rangeChanged = (+(cachedRange.min) !== +(range.min)) || (+(cachedRange.max) !== +(range.max))
+
+                if (scoreChanged || rateChanged || positionChanged || rangeChanged) {
+                    let newValueMessage = `New value \`${score}\` with rate \`${rate}%\`, and at the \`${position}\` place in range ${range.min}..${range.max}.`
 
-                if (scoreChanged || rateChanged || positionChanged) {
-                    let newValueMessage = `New value \`${score}\` with rate \`${rate}%\`, and at the \`${position}\` place in range ${positions[0]}...${positions[positions.length - 1]}.`
                     if (scoreChanged) {
-                        message = `Your uptime score changed ${score > cachedScore ? 'UP' : 'DOWN'}!`
+                        message = `Your uptime score changed ${+score > +cachedScore ? 'UP' : 'DOWN'}!`
                     } else if (rateChanged) {
-                        message = `Your uptime rate changed ${rate > cachedRate ? 'UP' : 'DOWN'}!`
+                        message = `Your uptime rate changed ${+rate > +cachedRate ? 'UP' : 'DOWN'}!`
+                    } else if (positionChanged) {
+                        message = `Your uptime position changed ${+position > +cachedPosition ? 'UP' : 'DOWN'}!`
+                    } else if (rangeChanged) {
+                        message = `Your uptime range changed from ${cachedRange.min}..${cachedRange.max} to ${range.min}..${range.max}`
                     } else {
                         message = `Your uptime position changed!`
                     }
@@ -59,18 +41,14 @@ const processUptime = async () => {
 
             if (message) sendMessage("UPTIME", message)
 
-            globalThis.cache.uptime = {
-                ...uptime,
-                positions
-            }
+            globalThis.cache.uptime = data
         }
+
     } catch (e) {
-        console.error(e)
+        error(e.message)
     }
-
-    setTimeout(processUptime, uptimeUpdateInterval)
 }
 
 module.exports = {
-    processUptime
+    processUptime,
 }

server/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mina_monitor_server",
-  "version": "2.1.2",
+  "version": "2.2.0",
   "license": "MIT",
   "main": "index.js",
   "scripts": {