@cloudbase/cli 2.12.8 → 2.12.9-beta.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cloudbase/cli",
-  "version": "2.12.8",
+  "version": "2.12.9-beta.0",
   "description": "CLI for Tencent CloudBase (standalone bundle)",
   "bin": {
     "tcb": "bin/tcb",
@@ -11,7 +11,8 @@
   "files": [
     "bin",
     "dist/standalone",
-    "dist/fonts"
+    "dist/fonts",
+    "runtime/nodejs"
   ],
   "license": "ISC"
 }

package/runtime/nodejs/bootstrap.js

@@ -0,0 +1,255 @@
+/* eslint-disable */
+var runtime = require('./runtime')
+var util = require('util')
+
+var initHandlerFault = 'function initialization failed'
+var maxRetMsgLen = 6 * 1024 * 1024 // byte
+var maxRetMsgLenExceedError = 'body size is too long'
+var httpHandler, eventHandler
+
+var _result, _fault
+var _user_exception = false
+
+function wrapLog(invokeId) {
+    console.log = console.info = function prettyConsoleLog() {
+        var message = `${util.format.apply(this, arguments)}`
+        runtime.console_log(message)
+    }
+    console.error = console.warn = function prettyConsoleLogErr() {
+        var message = `${util.format.apply(this, arguments)}`
+        runtime.console_log(message, (err = true))
+    }
+}
+
+function main() {
+    if (0 != runtime.init()) {
+        console.log('runtime init failed')
+        return
+    }
+    runtime.log('init succ')
+
+    cleanEnv()
+
+    process.on('beforeExit', () => {
+        runtime.log('catch exit')
+        finish(null, null, false)
+    })
+    process.on('uncaughtException', err => {
+        runtime.log('catch exception')
+        finish(err, null, false)
+    })
+
+    waitForInvoke()
+}
+
+function cleanEnv() {
+    var envToDelete = ['SOCKETPATH', 'CONTAINERID']
+    for (var k in process.env) {
+        if (k.startsWith('KUBERNETES')) {
+            envToDelete.push(k)
+        }
+    }
+
+    envToDelete.forEach(e => {
+        delete process.env[e]
+    })
+}
+
+function waitForInvoke() {
+    runtime.log('wait for invoke')
+    var invokeInfo = runtime.wait_for_invoke()
+    setTimeout(() => {
+        runtime.log('timed out, invoke')
+        invoke(invokeInfo)
+    }, 0)
+}
+
+function invoke(invokeInfo) {
+    if (invokeInfo.cmd === 'RELOAD') {
+        runtime.log(`get reload request: ${invokeInfo.context}`)
+        // 路径中可能包含 . 符号
+        var ff = invokeInfo.globalHandler.split('.')
+        initHandler(invokeInfo.filePath + ff[0], ff[1])
+        runtime.log('handlers reloaded')
+        _result = 'reload'
+        finish(null, null, false)
+        return
+    }
+
+    _result = undefined
+    _fault = undefined
+
+    runtime.report_running()
+
+    var ev, ctx
+    if (invokeInfo.event || invokeInfo.context) {
+        try {
+            ev = JSON.parse(invokeInfo.event)
+            ctx = JSON.parse(invokeInfo.context)
+        } catch (err) {
+            _fault = `eval event[${invokeInfo.event}] or context [${invokeInfo.context}] failed\n${err}`
+            return
+        }
+    }
+
+    ctx['environ'].split(';').forEach(e => {
+        if (e == '') return
+        var kv = e.split('=', 2)
+        process.env[kv[0]] = kv[1]
+    })
+
+    runtime.log(`request[${ctx['request_id']}] invoked`)
+
+    if (!httpHandler && !eventHandler) {
+        _fault = initHandlerFault
+        return
+    }
+
+    wrapLog(ctx['request_id'])
+    if (invokeInfo.cmd === 'HTTP') {
+        httpHandler.handle(invokeInfo.sockfd)
+    } else if (invokeInfo.cmd === 'EVENT') {
+        eventHandler.handle(ev, ctx)
+    } else {
+        _fault = `recv unknown task type: ${invokeInfo.cmd}`
+        runtime.log(`recv unknown task type: ${invokeInfo.cmd}`)
+    }
+
+    runtime.log('process finished')
+}
+
+function initHandler(file, func) {
+    try {
+        var path = require('path')
+        var current_path = path.dirname(file)
+        process.chdir(current_path)
+        runtime.log(`working directory: ${process.cwd()}`)
+
+        for (var item in require.cache) {
+            delete require.cache[item]
+        }
+        var usermod = require(file)
+        httpHandler = new HttpHandler(usermod[func])
+        eventHandler = new EventHandler(usermod[func])
+    } catch (err) {
+        runtime.log(`get user function[${file}:${func}] failed`)
+        runtime.log(err.stack)
+        initHandlerFault = err.message
+        _user_exception = true
+    }
+}
+
+function finish(err, data, wait) {
+    runtime.log('finish')
+    runtime.log(wait ? 'wait' : 'not wait')
+
+    if (_result === undefined) {
+        if (err == null) {
+            try {
+                _result = JSON.stringify(data === undefined ? null : data)
+            } catch (err) {
+                _result = 'faulted'
+                _fault = `stringify response to json failed: ${err.message}`
+                return
+            }
+        } else {
+            _result = 'faulted'
+            if (err instanceof Error) {
+                runtime.console_log(err.stack, true)
+                _fault = err.message
+            } else {
+                var errStr = String(err)
+                _fault = `${errStr}(callback err is not instance of Error)`
+            }
+        }
+    }
+
+    if (wait) {
+        return
+    }
+
+    runtime.log(_result)
+    process.nextTick(() => {
+        if (_result == 'reload') {
+            // reload response, do nothing
+        } else if (_fault !== undefined) {
+            _user_exception = true
+            var errType = _user_exception ? 2 : 1
+            runtime.report_fail(_fault, 0, errType)
+        } else if (_result.length > maxRetMsgLen) {
+            runtime.report_fail(maxRetMsgLenExceedError, 0, 1)
+        } else {
+            runtime.report_done(_result, 0)
+        }
+        waitForInvoke()
+    })
+}
+
+class HttpHandler {
+    constructor(func) {
+        this.realHandler = func
+    }
+
+    handle(fd) {}
+}
+
+class EventHandler {
+    constructor(func) {
+        this.realHandler = func
+    }
+
+    handle(ev, ctx) {
+        var called = false
+        var wait = true
+        var callback = (err, data) => {
+            if (called) {
+                return
+            }
+            called = true
+            finish(err, data, wait)
+        }
+
+        var ctxx = Object.assign(
+            {
+                set callbackWaitsForEmptyEventLoop(value) {
+                    wait = value
+                },
+                get callbackWaitsForEmptyEventLoop() {
+                    return wait
+                },
+                getContext() {
+                    return ctx
+                },
+                done: function(err, data) {
+                    wait = false
+                    callback(err, data)
+                },
+                succeed: function(data) {
+                    ctxx.done(null, data)
+                },
+                fail: function(err) {
+                    ctxx.done(err, null)
+                }
+            },
+            ctx
+        )
+
+        try {
+            _user_exception = false
+            var ret = this.realHandler(ev, ctxx, callback)
+            if (
+                ret &&
+                ret.then !== undefined &&
+                typeof ret.then === 'function'
+            ) {
+                ret.then(ctxx.succeed, ctxx.fail)
+            }
+        } catch (err) {
+            runtime.console_log(err.stack, true)
+            _fault = err.stack
+            _user_exception = true
+        }
+    }
+}
+
+main()

package/runtime/nodejs/runtime.js

@@ -0,0 +1,183 @@
+/* eslint-disable */
+const fs = require('fs')
+const crypto = require('crypto')
+
+var GLOBAL_FUNCTION_HANDLER = process.argv[2] || process.env.SCF_FUNCTION_HANDLER || 'index.main'
+var GLOBAL_FUNCTION_NAME = process.env.SCF_FUNCTION_NAME || 'main'
+var GLOBAL_EVENT_BODY =
+    process.argv[3] ||
+    process.env.SCF_EVENT_BODY ||
+    (process.env.DOCKER_USE_STDIN && fs.readFileSync('/dev/stdin', 'utf8')) ||
+    '{}'
+
+var GLOBAL_USER_FILE_PATH = process.env.GLOBAL_USER_FILE_PATH || ''
+var GLOBAL_VERSION = process.env.SCF_FUNCTION_VERSION || '$LATEST'
+var GLOBAL_MEM_SIZE = process.env.SCF_FUNCTION_MEMORY_SIZE || '256'
+var GLOBAL_TIMEOUT = process.env.SCF_FUNCTION_TIMEOUT || '3'
+var GLOBAL_ENVIRON = process.env.SCF_FUNCTION_ENVIRON || ''
+var GLOBAL_IS_QUIET = process.env.SCF_DISPLAY_IS_QUIET === 'True' || false
+
+var GLOBAL_REQUEST_ID = uuid()
+var GLOBAL_START_TIME = process.hrtime()
+var GLOBAL_SOCK = -1
+var GLOBAL_STAGE = 0
+
+module.exports = {
+    init: function() {
+        if (!GLOBAL_IS_QUIET) {
+            consoleLog('开始本地执行云函数，受环境影响，执行结果可能与云端存在一定差异！')
+            consoleLog('START RequestId: ' + GLOBAL_REQUEST_ID)
+        }
+        return 0
+    },
+    wait_for_invoke: function() {
+        var invokeInfo = []
+
+        GLOBAL_STAGE += 1
+        switch (GLOBAL_STAGE) {
+            case 1:
+                invokeInfo.cmd = 'RELOAD'
+                invokeInfo.context = GLOBAL_USER_FILE_PATH + GLOBAL_FUNCTION_HANDLER
+                invokeInfo.globalHandler = GLOBAL_FUNCTION_HANDLER
+                invokeInfo.filePath = GLOBAL_USER_FILE_PATH
+                break
+            case 2:
+                invokeInfo.cmd = 'EVENT'
+                invokeInfo.sockfd = GLOBAL_SOCK
+                invokeInfo.event = GLOBAL_EVENT_BODY
+                invokeInfo.context = initContext()
+                break
+            default:
+                process.exit()
+        }
+
+        return invokeInfo
+    },
+    log: function(str) {
+        // consoleLog(formatSystem(str))
+    },
+    console_log: function(str, err = false) {
+        if (!GLOBAL_IS_QUIET) {
+            if (err === false) {
+                consoleLog(formatConsole(str))
+            } else {
+                consoleLogErr(formatConsole(str))
+            }
+        }
+    },
+    report_fail: function(stackTrace, errNum, errType = 0) {
+        const result = {}
+
+        result['errorCode'] = 1
+        result['errorMessage'] = 'user code exception caught'
+        if (stackTrace) {
+            result['stackTrace'] = stackTrace
+        }
+
+        reportDone('', (errType = 1))
+        // console.dir(result);
+        consoleLogErr(JSON.stringify(result))
+    },
+    report_running: function() {
+        GLOBAL_START_TIME = process.hrtime()
+    },
+    report_done: function(resultStr, errType = 0) {
+        reportDone(resultStr, errType)
+    }
+}
+
+function initContext() {
+    var context = {}
+    context['function_version'] = GLOBAL_VERSION
+    context['function_name'] = GLOBAL_FUNCTION_NAME
+
+    context['time_limit_in_ms'] = GLOBAL_TIMEOUT
+    context['memory_limit_in_mb'] = GLOBAL_MEM_SIZE
+
+    context['request_id'] = GLOBAL_REQUEST_ID
+    context['environ'] = GLOBAL_ENVIRON
+
+    return JSON.stringify(context)
+}
+
+function reportDone(resultStr, errType = 0) {
+    if (GLOBAL_IS_QUIET) {
+        if (typeof resultStr === 'string') {
+            if (errType === 0) consoleLog(resultStr)
+            else consoleLogErr(resultStr)
+        }
+        return
+    }
+
+    var diffMs = hrTimeMs(process.hrtime(GLOBAL_START_TIME))
+    var billedMs = Math.min(100 * (Math.floor(diffMs / 100) + 1), GLOBAL_TIMEOUT * 1000)
+    if (errType === 0) {
+        consoleLog('END RequestId: ' + GLOBAL_REQUEST_ID)
+        consoleLog(
+            [
+                '运行信息：',
+                'REPORT RequestId: ' + GLOBAL_REQUEST_ID,
+                'Duration: ' + diffMs.toFixed(2) + ' ms',
+                'Billed Duration: ' + billedMs + ' ms',
+                'Memory Size: ' + GLOBAL_MEM_SIZE + ' MB',
+                'Max Memory Used: ' + Math.round(process.memoryUsage().rss / (1024 * 1024)) + ' MB'
+            ].join('\n')
+        )
+    } else {
+        consoleLogErr(
+            [
+                '运行信息：',
+                'REPORT RequestId: ' + GLOBAL_REQUEST_ID,
+                'Duration: ' + diffMs.toFixed(2) + ' ms',
+                'Billed Duration: ' + billedMs + ' ms',
+                'Memory Size: ' + GLOBAL_MEM_SIZE + ' MB',
+                'Max Memory Used: ' + Math.round(process.memoryUsage().rss / (1024 * 1024)) + ' MB'
+            ].join('\n')
+        )
+    }
+
+    if (typeof resultStr === 'string') {
+        if (errType === 0) {
+            consoleLog('返回结果：\n' + resultStr)
+        } else {
+            consoleLogErr('返回结果：\n' + resultStr)
+        }
+    }
+}
+
+function consoleLog(str) {
+    process.stdout.write(str + '\n')
+}
+
+function consoleLogErr(str) {
+    process.stderr.write(str + '\n')
+}
+
+function formatConsole(str) {
+    return str.replace(/^[0-9TZ:.-]+\t[0-9a-f-]+\t/, '\u001b[34m$&\u001b[0m')
+}
+
+function formatSystem(str) {
+    return '\u001b[32m' + str + '\u001b[0m'
+}
+
+function hrTimeMs(hrtime) {
+    return (hrtime[0] * 1e9 + hrtime[1]) / 1e6
+}
+
+function uuid() {
+    return (
+        crypto.randomBytes(4).toString('hex') +
+        '-' +
+        crypto.randomBytes(2).toString('hex') +
+        '-' +
+        crypto
+            .randomBytes(2)
+            .toString('hex')
+            .replace(/^./, '1') +
+        '-' +
+        crypto.randomBytes(2).toString('hex') +
+        '-' +
+        crypto.randomBytes(6).toString('hex')
+    )
+}