@cloudbase/manager-node 4.2.3 → 4.2.5

package/src/utils/envLazy.ts

@@ -1,15 +0,0 @@
-export function preLazy() {
-    return function(target: any, propertyKey: string, descriptor: PropertyDescriptor) {
-        let oldFunc = descriptor.value
-        descriptor.value = async function() {
-            // 检查当前环境对象上是否已加载好环境信息
-            const currentEnvironment = this.environment
-
-            if (!currentEnvironment.inited) {
-                await currentEnvironment.lazyInit()
-            }
-            let result = await oldFunc.apply(this, arguments)
-            return result
-        }
-    }
-}

package/src/utils/fs.ts

@@ -1,57 +0,0 @@
-import fs from 'fs'
-import { CloudBaseError } from '../error'
-import del from 'del'
-
-type SizeUnit = 'MB' | 'GB'
-
-// 检查路径是否可以访问（读、写）
-export function checkFullAccess(dest: string, throwError = false): boolean {
-    try {
-        // 可见、可写
-        fs.accessSync(dest, fs.constants.F_OK)
-        fs.accessSync(dest, fs.constants.W_OK)
-        fs.accessSync(dest, fs.constants.R_OK)
-        return true
-    } catch (e) {
-        if (throwError) {
-            throw new CloudBaseError(`路径不存在或无读写权限：${dest}`)
-        } else {
-            return false
-        }
-    }
-}
-
-// 检查路径是否可以写
-export function checkReadable(dest: string, throwError = false): boolean {
-    try {
-        // 可见、可读
-        fs.accessSync(dest, fs.constants.F_OK)
-        fs.accessSync(dest, fs.constants.R_OK)
-        return true
-    } catch (e) {
-        if (throwError) {
-            throw new CloudBaseError(`路径不存在或无读权限：${dest}`)
-        } else {
-            return false
-        }
-    }
-}
-
-export function isDirectory(dest: string) {
-    checkFullAccess(dest, true)
-    return fs.statSync(dest).isDirectory()
-}
-
-export function formateFileSize(size: number, unit: SizeUnit) {
-    const unitMap = {
-        KB: 1024,
-        MB: Math.pow(1024, 2),
-        GB: Math.pow(1024, 3)
-    }
-
-    return Number(size / unitMap[unit]).toFixed(2)
-}
-
-export function delSync(patterns: string | readonly string[]) {
-    del.sync(patterns, { force: true })
-}

package/src/utils/http-request.ts

@@ -1,37 +0,0 @@
-import { URL } from 'url'
-import _fetch from 'node-fetch'
-import HttpsProxyAgent from 'https-proxy-agent'
-import { CloudBaseError } from '../error'
-
-// 使用 fetch + 代理
-export async function fetch(url: string, config: Record<string, any> = {}, proxy) {
-    if (proxy || process.env.http_proxy) {
-        config.agent = new HttpsProxyAgent(proxy || process.env.http_proxy)
-    }
-    // 解决中文编码问题
-    const escapeUrl = new URL(url).toString()
-    let json
-    let text
-    try {
-        const res = await _fetch(escapeUrl, config)
-        text = await res.text()
-        json = JSON.parse(text)
-    } catch (e) {
-        // 某些情况下回返回 HTML 文本异常
-        // JSON 解析错误，抛出原响应文本
-        if (e.name === 'SyntaxError') {
-            throw new CloudBaseError(text)
-        }
-        throw new CloudBaseError(e)
-    }
-    return json
-}
-
-export async function fetchStream(url: string, config: Record<string, any> = {}, proxy) {
-    if (proxy || process.env.http_proxy) {
-        config.agent = new HttpsProxyAgent(proxy || process.env.http_proxy)
-    }
-    // 解决中文编码问题
-    const escapeUrl = new URL(url).toString()
-    return _fetch(escapeUrl, config)
-}

package/src/utils/index.ts

@@ -1,103 +0,0 @@
-import fs from 'fs'
-import archiver from 'archiver'
-import crypto from 'crypto'
-import { PUBLIC_RSA_KEY, ENV_NAME } from '../constant'
-
-export { guid6 } from './uuid'
-export * from './cloud-api-request'
-export * from './auth'
-export * from './cloudbase-request'
-export * from './http-request'
-export * from './envLazy'
-export * from './fs'
-
-interface IZipOption {
-    dirPath: string
-    outputPath: string
-    ignore?: string | string[]
-    pattern?: string
-}
-
-export async function compressToZip(option: IZipOption) {
-    const { dirPath, outputPath, ignore, pattern = '**/*' } = option
-
-    return new Promise((resolve, reject) => {
-        const output = fs.createWriteStream(outputPath)
-        const archive = archiver('zip')
-
-        output.on('close', function () {
-            resolve({
-                zipPath: outputPath,
-                size: Math.ceil(archive.pointer() / 1024)
-            })
-        })
-
-        archive.on('error', function (err) {
-            reject(err)
-        })
-
-        archive.pipe(output)
-        // append files from a glob pattern
-        archive.glob(pattern, {
-            // 目标路径
-            cwd: dirPath,
-            ignore: ignore,
-            dot: true
-        })
-        archive.finalize()
-    })
-}
-
-export function getRuntime(): string {
-    return process.env[ENV_NAME.ENV_RUNENV]
-}
-
-export function getEnvVar(envName: string): string {
-    return process.env[envName]
-}
-
-export function rsaEncrypt(data: string): string {
-    const buffer = Buffer.from(data)
-    const encrypted = crypto.publicEncrypt(
-        {
-            key: PUBLIC_RSA_KEY,
-            padding: crypto.constants.RSA_PKCS1_PADDING
-        },
-        buffer
-    )
-    return encrypted.toString('base64')
-}
-
-export function sleep(time: number): Promise<void> {
-    return new Promise(resolve => {
-        setTimeout(() => {
-            resolve()
-        }, time)
-    })
-}
-
-export function upperCaseStringFisrt(str: string) {
-    return str.slice(0, 1).toUpperCase().concat(str.slice(1))
-}
-
-export function upperCaseObjKey(object: any) {
-    const type = Object.prototype.toString.call(object).slice(8, -1)
-    if (type === 'Object') {
-        let newObj = {}
-        // eslint-disable-next-line guard-for-in
-        for (let key in object) {
-            newObj[upperCaseStringFisrt(key)] = upperCaseObjKey(object[key])
-        }
-        return newObj
-    }
-
-    if (type === 'Array') {
-        let newArr = []
-        for (let item of object) {
-            newArr.push(upperCaseObjKey(item))
-        }
-        return newArr
-    }
-
-    return object
-}

package/src/utils/parallel.ts

@@ -1,82 +0,0 @@
-export type AsyncTask = () => Promise<any>
-
-/**
- * 异步任务并发控制器，以一定的并发数执行所有任务
- * 不具备队列性质，异步任务随机执行
- * 单个任务异常，错误会返回，单不会退出执行
- * 所有任务执行
- */
-export class AsyncTaskParallelController {
-    // 任务最大并发数
-    maxParallel: number
-    // 异步任务队列
-    tasks: AsyncTask[]
-    // 检查间隔时间，单位 ms
-    checkInterval: number
-    // 所有任务数量
-    totalTasks: number
-
-    constructor(maxParallel: number, checkInterval = 20) {
-        this.tasks = []
-        this.maxParallel = Number(maxParallel) || 20
-        this.checkInterval = checkInterval
-    }
-
-    loadTasks(tasks: AsyncTask[]) {
-        this.tasks.push(...tasks)
-        this.totalTasks = this.tasks.length
-    }
-
-    push(task: AsyncTask) {
-        this.tasks.push(task)
-        this.totalTasks = this.tasks.length
-    }
-
-    // 开始执行任务
-    async run(): Promise<any[]> {
-        // 存储任务执行结果
-        const results = []
-        // 记录已经运行的任务
-        const taskHasRun = []
-        // 记录任务是否执行完成
-        const taskDone = []
-        // 当前正在运行的任务数量
-        let runningTask = 0
-
-        return new Promise(resolve => {
-            // 使用定时器，不阻塞线程
-            const timer = setInterval(() => {
-                // 全部任务运行完成
-                const taskDoneLength = taskDone.filter(item => item).length
-                if (runningTask === 0 && taskDoneLength === this.totalTasks) {
-                    clearInterval(timer)
-                    resolve(results)
-                }
-
-                // 当前运行任务数超过最大并发，不再执行新的任务
-                if (runningTask >= this.maxParallel) {
-                    return
-                }
-
-                // 遍历任务列表，开始执行还没有执行的任务
-                this.tasks.forEach((task, index) => {
-                    if (!taskHasRun[index] && runningTask < this.maxParallel) {
-                        runningTask++
-                        taskHasRun[index] = 1
-                        task()
-                            .then(res => {
-                                results[index] = res
-                            })
-                            .catch(err => {
-                                results[index] = err
-                            })
-                            .then(() => {
-                                runningTask--
-                                taskDone[index] = 1
-                            })
-                    }
-                })
-            }, this.checkInterval)
-        })
-    }
-}

package/src/utils/uuid.ts

@@ -1,14 +0,0 @@
-// 环境 uuid
-export function guid6() {
-    return Math.floor((1 + Math.random()) * 0x1000000)
-        .toString(16)
-        .substring(1)
-}
-
-export function uuidv4() {
-    return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, function(c) {
-        const r = (Math.random() * 16) | 0
-        const v = c === 'x' ? r : (r & 0x3) | 0x8
-        return v.toString(16)
-    })
-}