jsir 1.2.6 → 1.2.9

package/util.js

@@ -1,28 +1,39 @@
 const setting = require('./setting')
 const os = require('os')
 const home = os.homedir()
-const exec = require('child_process').exec;
+const {exec, spawnSync} = require('child_process');
 const readline = require('readline')
 const fs = require('fs')
 const http = require("http");
 const querystring = require('querystring');
 const axios = require('axios')
 const got = axios.create({
-    timeout: 9000
+    timeout: 33000
 })
 const BigNumber = require('bignumber.js');
 const pad = require('pad');
-let crypto = require('crypto');
+const crypto = require('crypto');
 const globalDirectories = require('global-dirs');
-let md5 = require('md5');
 const emptyFn = ()=>{}
 const dayJs = require('dayjs')
+const table = require('console.table')
+
 let _globalLog = createLimitLogger2(`${setting.name}.log`, null, false)
 global.$log = str => {
-    _globalLog(`[${timeStr()}] ${str}`)
+    str = trim(str)
+    if (str) {
+        _globalLog(`[${timeStr()}] ${str}`)
+    }
 }
 const $log = global.$log
-const $fnCache = {}
+let _globalDraft= createLimitLogger2(`draft.log`, null, false)
+global.$draft = str => {
+    if (trim(str)) {
+        _globalDraft(`---------${timeStr()}\n${str.split("\n").filter(i => trim(i)).join("\n")}`)
+    }
+}
+const $draft = global.$draft
+global.$fnCache = {}
 
 global.$config = {
     _buildId: null,
@@ -38,7 +49,7 @@ global.$config = {
     localConfig: {},
     remoteConfig: {},
     getLocal: (key, defaultVal) => {
-        if (key && !$config.localConfig.hasOwnProperty(key)) {
+        if (key && Object.keys($config.localConfig).indexOf(key) === -1) {
             getConfig(key)
         }
         return getVl($config.localConfig[key], defaultVal)
@@ -76,6 +87,14 @@ async function _buildConfig() {
     $config._buildId = setTimeout(_buildConfig, 3000);
 }
 
+function tableStr(...args) {
+    return trim(table.getTable(...args))
+}
+
+function nableStr(rows) {
+    return tableStr(wrapRows(rows))
+}
+
 function timeStr(fmt, date) {
     return dayJs(date || new Date()).format(fmt || 'YYYY/MM/DD HH:mm:ss')
 }
@@ -84,6 +103,9 @@ function vl(obj) {
     if (typeof obj === 'number') {
         return !Number.isNaN(obj)
     }
+    if (typeof obj === 'string') {
+        obj = trim(obj)
+    }
     return !(obj === null || obj === undefined || obj === '')
 }
 
@@ -95,17 +117,39 @@ function getVl(...obj) {
     }
 }
 
-async function cacheFn(key, fn, validMs) {
-    if ($fnCache[key] && Date.now() <= $fnCache[key].expiredMs) {
+let cacheFnResp;
+async function cacheFn(key, fn, validMs, awaitRefresh) {
+    getOr($fnCache, key, {
+        validMsTime: 0
+    });
+    if (Date.now() <= $fnCache[key].validMsTime) {
         // do nothing
     } else {
-        await (async () => {
-            let val = await fn()
+        $fnCache[key].validMsTime = Date.now() * 3;
+        let sync = true
+        cacheFnResp =  (async () => {
+            let val;
+            try {
+                val = await fn()
+            } finally {
+                if (!$fnCache[key].validMsTime > Date.now() * 2) {
+                    sync = false
+                } else {
+                    $fnCache[key].validMsTime = 0
+                }
+            }
+            if (!sync) {
+                return;
+            }
             $fnCache[key] = {
                 val,
-                expiredMs: Date.now() + (validMs || 1000 * 60 * 60 * 24 * 1000)
+                valInit: true,
+                validMsTime: Date.now() + (validMs || Date.now())
             }
-        })()
+        })();
+    }
+    if (awaitRefresh || !$fnCache[key].valInit) {
+        await cacheFnResp;
     }
     return $fnCache[key].val
 }
@@ -162,7 +206,11 @@ function createLimitLogger(fileName, maxChars, logInfo = true) {
     }
 
     return (text) => {
-        fs.appendFile(logPath, String(text) + '\n', emptyFn)
+        text = trim(text)
+        if (!text) {
+            return
+        }
+        fs.appendFile(logPath, text + '\n', emptyFn)
     }
 }
 
@@ -170,7 +218,6 @@ function createLimitLogger2(fileName, maxChars, logInfo = true) {
     let logDir = getLibDataDir() + "/log"
     mkdir(logDir)
     let logPath = logDir + "/" + fileName
-    cleanFile(logPath, maxChars)
 
     if (logInfo) {
         info(`log: ${logPath}`)
@@ -178,12 +225,16 @@ function createLimitLogger2(fileName, maxChars, logInfo = true) {
 
     let minNum = (Date.now()/(1000 * 60 * 10)).toFixed(0)
     return (text) => {
+        text = trim(text)
+        if (!text) {
+            return
+        }
         let _minNum = (Date.now()/(1000 * 60 * 10)).toFixed(0)
         if (_minNum !== minNum) {
             minNum = _minNum
             cleanFile(logPath, maxChars)
         }
-        fs.appendFile(logPath, String(text) + '\n', emptyFn)
+        fs.appendFile(logPath, text + '\n', emptyFn)
     }
 }
 
@@ -200,13 +251,17 @@ function textDataFile(fileName, fn) {
         return text
     }
     let val = fn(text)
-    if (vl(val) && val.constructor.name === 'Promise') {
+    if (vl(val) && getType(val) === 'Promise') {
         return val.then(result => {
-            fileLock(fileName, () => fs.writeFileSync(path, result))
+            if (vl(result) || String(result) === '') {
+                fileLock(fileName, () => fs.writeFileSync(path, result))
+            }
             return result
         })
     } else {
-        fileLock(fileName, () => fs.writeFileSync(path, val))
+        if (vl(val) || String(val) === '') {
+            fileLock(fileName, () => fs.writeFileSync(path, val))
+        }
         return val
     }
 }
@@ -230,7 +285,7 @@ function dataFile(fileName, fn, fmt, defaultObj = {}) {
         return obj
     }
     let val = fn(obj)
-    if (vl(val) && val.constructor.name === 'Promise') {
+    if (vl(val) && getType(val) === 'Promise') {
         return new Promise(async resolve => {
             let result = await val
             if (result && typeof result === 'object') {
@@ -262,23 +317,43 @@ function requireG(module){
     return require(path);
 }
 
+function validStr(str, name) {
+    if (!vl(str) || typeof str !== 'string') {
+        throw "invalid cipher " + name;
+    }
+}
+
 function aesCipher(str, key){
+    validStr(str, "str");
+    validStr(key, "key");
+
+    key = trim(key);
+    if (!key || key.length > 16) {
+        throw "aesCipher key length should between 1 and 16"
+    }
     try {
         const cipher = crypto.createCipheriv('aes-128-ecb', pad(key, 16, '0'), null);
         return cipher.update(str, 'utf8', 'hex') + cipher.final('hex');
     } catch(err) {
-        console.log('加密失败');
-        return err.message || err;
+        $log(errorStack(err))
+        throw 'aesCipher failed: ' + String(err)
     }
 }
 
 function aesDecipher(str, key){
+    validStr(str, "str");
+    validStr(key, "key");
+
+    key = trim(key);
+    if (!key || key.length > 16) {
+        throw "aesCipher key length should between 1 and 16"
+    }
     try {
         const decipher = crypto.createDecipheriv('aes-128-ecb', pad(key, 16, '0'), null);
         return decipher.update(str, 'hex', 'utf8') + decipher.final('utf8');
     } catch(err) {
-        console.log('解密失败');
-        return err.message || err;
+        $log(errorStack(err))
+        throw 'aesDecipher failed: ' + String(err)
     }
 }
 
@@ -439,7 +514,7 @@ function fileLock(key, fn) {
     } catch (e) {
         rmDir(file)
     }
-    if (obj && obj.constructor.name === 'Promise') {
+    if (getType(obj)=== 'Promise') {
         return obj.then(result => {
             rmDir(file)
             return result
@@ -483,14 +558,13 @@ function fileCleaner(path, maxChars) {
         global.$cleanFiles[path] = 0
     }
 
-    cleanFile(path, maxChars)
     if (!global.$fileCleanerOn) {
         timeLoop(() => {
             for (let aPath of Object.keys(global.$cleanFiles)) {
                 try {
                     cleanFile(path, maxChars)
                 } catch (e) {
-                    console.log(e.toString().split("\n")[0])
+                    console.log(String(e))
                 }
                 global.$cleanFiles[path] ++
             }
@@ -504,7 +578,7 @@ function cleanFile(path, maxChars) {
         return
     }
     let content = String(fs.readFileSync(path))
-    let newContext = content.substr(- (maxChars || 1024 * 1000))
+    let newContext = content.substr(- (maxChars || 1024 * 1024))
     if (newContext.length < content.length) {
         fs.writeFileSync(path, newContext)
     }
@@ -594,18 +668,18 @@ function timeLoop(fn, timestamp, lastIds = []){
     try {
         val = fn()
     } catch (e) {
-        console.error(e.toString().split("\n")[0])
-        $log(e.stack)
+        error(String(e))
+        $log(new Error(errorStack(e)).stack)
     }
-    if (vl(val) && val.constructor.name === 'Promise') {
+    if (vl(val) && getType(val) === 'Promise') {
         return val.then(result => {
             if (lastIds[0] !== false && result !== true) {
                 lastIds[0] = setTimeout(() => timeLoop(fn, timestamp, lastIds), timestamp)
             }
             return lastIds
         }).catch(e => {
-            console.error(e.toString().split("\n")[0])
-            $log(e.stack)
+            error(String(e))
+            $log(new Error(errorStack(e)).stack)
 
             if (lastIds[0] !== false) {
                 lastIds[0] = setTimeout(() => timeLoop(fn, timestamp, lastIds), timestamp)
@@ -654,6 +728,9 @@ function e(cmd, mbNum, doTrim = true){
                 maxBuffer: 1024 * 1024 * (mbNum || 3) //quick fix
             },
             function (err, stdout, stderr) {
+                if (stderr) {
+                    reject(trim(stderr))
+                }
                 resolve(doTrim ? trim(stdout):String(stdout))
             });
     })
@@ -670,6 +747,10 @@ function ee(cmd, mbNum, doTrim = true){
     })
 }
 
+function ei(cmd, args = []) {
+    spawnSync(cmd, args, {stdio:"inherit"});
+}
+
 async function getCbText() {
     return await e(`pbpaste`, null, false)
 }
@@ -712,7 +793,7 @@ function splitArray(items, size) {
 }
 
 function isError(obj) {
-    return obj && obj.constructor && obj.constructor.name === 'Error'
+    return getType(obj).endsWith('Error')
 }
 
 class Range {
@@ -786,24 +867,35 @@ function wrapRows(rows) {
 }
 
 function info(msg) {
-    process.stdout.write('\x1B[32m')
-    process.stdout.write('[info] ')
-    process.stdout.write('\x1B[39m')
-    console.log(msg)
+    console.log(infoStr('[info]'), msg)
+}
+
+function msg(msg) {
+    console.log(msgStr('[msg]'), msg)
 }
 
 function warn(msg) {
-    process.stdout.write('\x1B[33m')
-    process.stdout.write('[warn] ')
-    process.stdout.write('\x1B[39m')
-    console.log(msg)
+    console.warn(warnStr('[warn]'), msg)
 }
 
-function error(e, msg) {
-    process.stdout.write('\x1B[35m')
-    process.stdout.write(`[${msg || 'error'}] `)
-    process.stdout.write('\x1B[39m')
-    console.log(e)
+function error(msg, tag) {
+    console.error(errorStr(`[${tag || 'error'}]`), msg)
+}
+
+function infoStr(str) {
+    return `\x1B[32m${str}\x1B[39m`
+}
+
+function msgStr(str) {
+    return `\x1B[36m${str}\x1B[39m`
+}
+
+function warnStr(str) {
+    return `\x1B[33m${str}\x1B[39m`
+}
+
+function errorStr(str) {
+    return `\x1B[31m${str}\x1B[39m`
 }
 
 function parseSteps(str) {
@@ -839,6 +931,134 @@ function parseSteps(str) {
     return result
 }
 
+function errorStack(e) {
+    return String(e ? (e.stack || e):e)
+}
+
+function errorMsg(e) {
+    return trim(String(e).split("\n").map(trim).filter(i => i)[0])
+}
+
+function getType(obj) {
+    if (obj === '') {
+        return typeof obj;
+    }
+    if (!vl(obj)) {
+        return String(obj)
+    }
+    if (obj.constructor && obj.constructor.name) {
+        return obj.constructor.name;
+    }
+    return typeof obj
+}
+
+function getInfo(obj, key) {
+    let info = {}
+    if (key) {
+        info.key = key
+    }
+    if (!vl(obj)) {
+        info.type = getType(obj)
+        info.value = String(obj);
+        return info;
+    }
+
+    let value = ''
+    let str = trim(String(obj))
+    let fnName
+    if (typeof obj === 'function') {
+        fnName = obj.name
+        let fnStr = trim(str.split(/=\s*>|(?<=\))\s*{/)[0])
+        if (/[()]/.test(fnStr)) {
+            value = fnStr.split(/[()]/)[1]
+        } else {
+            value = fnStr
+        }
+        value = trim(value.split('\n').map(trim).join('\n      '))
+        if (value) {
+            value = 'args: ' + value
+        }
+    } else if (typeof obj === 'string') {
+        value = 'length: ' + str.length;
+    } else {
+        let len = Object.keys(obj).length;
+        value = len > 0 ? ('keys: ' + len) : (str.length <= 64 ? str : `${str.substr(0, 64)}...[length: ${str.length}]`);
+    }
+    key = key || fnName
+    if (key) {
+        info.key = key;
+    }
+    info.type = getType(obj);
+    info.value = value;
+    return info;
+}
+
+function md5(message) {
+    return crypto.createHash('md5').update(message).digest('hex');
+}
+
+async function batchAsync(fns = [], asyncNum = 1) {
+    if (fns.length <= 0 || asyncNum < 1) {
+        return []
+    }
+    let pros = []
+    let doneMap = {}
+    let proMap = {}
+    for(let i = 0; i< fns.length; i++) {
+        let pro = new Promise(async (resolve, reject) => {
+            try {
+                let resp = await fns[i]();
+                doneMap[i] = pro;
+                resolve(resp)
+            } catch (e) {
+                doneMap[i] = pro;
+                resolve(isError(e) ? e:new Error(e));
+            }
+        })
+        proMap[i] = pro;
+        pros.push(pro)
+
+        if (asyncNum === 1) {
+            await pro;
+        } else {
+            let undonePros = Object.keys(proMap).filter(i => !doneMap[i]).map(i => proMap[i])
+            if (undonePros.length >= asyncNum) {
+                await Promise.race(undonePros)
+            }
+        }
+    }
+    return await Promise.all(pros)
+}
+
+function objProfileRows(result) {
+    result = Object.keys(result).map(key => {
+        return {
+            key,
+            type: getType(result[key])
+        }})
+        .sort((a,b) => {
+            return a.type >= b.type ? 1:-1
+        })
+
+    let temp = []
+    for(let i = 0; i< Object.keys(result).length; i+=3) {
+        let item = {}
+        temp.push(item)
+
+        item['type'] = result[i].type
+        item['name']= result[i].key
+        if (result[i+1]) {
+            item['type '] = result[i+1].type
+            item['name ']= result[i+1].key
+        }
+        if (result[i+2]) {
+            item['type  '] = result[i+2].type
+            item['name  ']= result[i+2].key
+        }
+    }
+    return temp
+}
+
 module.exports = {
     run,
     reget,
@@ -910,5 +1130,21 @@ module.exports = {
     info,
     warn,
     error,
-    parseSteps
+    parseSteps,
+    $draft,
+    infoStr,
+    warnStr,
+    errorStr,
+    errorStack,
+    getType,
+    getInfo,
+    md5,
+    batchAsync,
+    ei,
+    msg,
+    msgStr,
+    errorMsg,
+    tableStr,
+    nableStr,
+    objProfileRows
 }