@cloudbase/cli 2.0.12-alpha.3 → 2.0.14

package/src/utils/checkTcbrEnv.ts

@@ -1,67 +0,0 @@
-import chalk from 'chalk'
-import { CloudBaseError } from '../error'
-import { CloudApiService } from './net'
-import { EnumEnvCheck } from '../constant'
-const tcbService = CloudApiService.getInstance('tcb')
-
-const oldCmdSet =
-    `
-服务列表：tcb run:deprecated list --envId <envId>
-创建服务：tcb run:deprecated create --envId <envId> --name <name>
-删除服务：tcb run:deprecated delete --envId <envId> --serviceName <serviceName>
-
-版本列表：tcb run:deprecated version list --envId <envId> --serviceName <serviceName>
-创建版本：tcb run:deprecated version create --envId <envId> --serviceName <serviceName>
-分配流量：tcb run:deprecated version modify --envId <envId> --serviceName <serviceName>
-滚动更新：tcb run:deprecated version update --envId <envId> --serviceName <serviceName> --versionName <versionName>
-删除版本：tcb run:deprecated version delete --envId <envId> --serviceName <serviceName> --versionName <versionName>
-
-查看镜像：tcb run:deprecated image list --envId <envId> --serviceName <serviceName>
-上传镜像：tcb run:deprecated image upload --envId <envId> --serviceName <serviceName> --imageId <imageId> --imageTag <imageTag>
-下载镜像：tcb run:deprecated image download --envId <envId> --serviceName <serviceName> --imageTag <imageTag>
-删除镜像：tcb run:deprecated image delete --envId <envId> --serviceName <serviceName> --imageTag <imageTag>
-`
-const newCmdSet =
-    `
-查看环境下服务：tcb run service:list --envId <envId>
-创建云托管服务：tcb run service:create --envId <envId> --serviceName <serviceName> --containerPort <containerPort>
-更新云托管服务：tcb run service:update --envId <envId> --serviceName <serviceName> --containerPort <containerPort>
-部署云托管服务：tcb run deploy --envId <envId> --serviceName <serviceName> --containerPort <containerPort>
-更新服务基础配置：tcb run service:config --envId <envId> --serviceName <serviceName>
-`
-/**
- * 
- * @param envId 环境 Id
- * @param isTcbr 使用的命令是否是 tcbr 新操作集
- * @returns 
- */
-export async function checkTcbrEnv(envId: string | undefined, isTcbr: boolean): Promise<EnumEnvCheck> | never {
-    if(envId === undefined) {
-        throw new CloudBaseError('请使用 -e 或 --envId 指定环境 ID')
-    }
-    const { EnvList: [envInfo] } = await tcbService.request('DescribeEnvs', {
-        EnvId: envId
-    })
-
-    if(envInfo === undefined) {
-        throw new CloudBaseError('无法读取到有效的环境信息，请检查环境 ID 是否正确')
-    }
-
-    if ((envInfo.EnvType === 'tcbr' && isTcbr) || (envInfo.EnvType !== 'tcbr' && !isTcbr)) {
-        return EnumEnvCheck.EnvFit
-    } else if (envInfo.EnvType === 'tcbr' && !isTcbr) {
-        return EnumEnvCheck.EnvNewCmdOld
-    } else if (envInfo.EnvType !== 'tcbr' && isTcbr) {
-        return EnumEnvCheck.EnvOldCmdNew
-    }
-}
-
-export function logEnvCheck(envId: string, warningType: EnumEnvCheck) {
-    if(warningType === EnumEnvCheck.EnvNewCmdOld) {
-        // 当前环境是 tcbr 环境且使用的不是 tcbr 新操作集
-        throw new CloudBaseError(`当前能力不支持 ${envId} 环境，请使用如下操作集：${chalk.grey(newCmdSet)}`)
-    } else if (warningType === EnumEnvCheck.EnvOldCmdNew) {
-        // 当前环境不是 tcbr 环境但使用 tcbr 操作集
-        throw new CloudBaseError(`当前能力不支持 ${envId} 环境，请使用如下操作集：${chalk.grey(oldCmdSet)}`)
-    }
-}

package/src/utils/cli-table.ts

@@ -1,23 +0,0 @@
-import Table, { TableOptions, HorizontalTable } from 'cli-table3'
-
-// 打印水平方向的表格
-export function printHorizontalTable(
-    head: string[],
-    data: (string | number)[][] = [],
-    options?: TableOptions
-) {
-    if (!data?.length) {
-        console.log('列表数据为空')
-    }
-    const table: HorizontalTable = new Table({
-        head,
-        style: { head: ['yellow'] },
-        colAligns: new Array(head.length).fill('center'),
-        ...options
-    }) as HorizontalTable
-
-    data.forEach((item: Table.Cell[]) => {
-        table.push(item)
-    })
-    console.log(table.toString())
-}

package/src/utils/commonParamsCheck.ts

@@ -1,65 +0,0 @@
-import { CloudBaseError } from '../error'
-import { convertNumber } from '../run'
-import { ITcbrServiceOptionalOptions, ITcbrServiceConvertedOptionalOptions } from '../types'
-import { validateCpuMem } from './validator'
-
-export function parseOptionalParams(options: ITcbrServiceOptionalOptions): ITcbrServiceConvertedOptionalOptions {
-    let cpuConverted
-    let memConverted
-    if (options.cpu || options.mem) {
-        let data = validateCpuMem(options.cpu, options.mem)
-        ;[cpuConverted, memConverted] = [data.cpuOutput, data.memOutput]
-    }
-
-    let maxNumConverted
-    if (options.maxNum) {
-        maxNumConverted = convertNumber(options.maxNum)
-        if (maxNumConverted < 0 || maxNumConverted > 50) {
-            throw new CloudBaseError('最大副本数必须大于等于0且小于等于50')
-        }
-    }
-
-    let minNumConverted
-    if (options.minNum) {
-        minNumConverted = convertNumber(options.minNum)
-        if (minNumConverted < 0 || minNumConverted > 50) {
-            throw new CloudBaseError('最小副本数必须大于等于0且小于等于50')
-        }
-    }
-
-    if (minNumConverted > maxNumConverted) {
-        throw new CloudBaseError('最小副本数不能大于最大副本数')
-    }
-
-    return {
-        cpuConverted,
-        memConverted,
-        maxNumConverted,
-        minNumConverted
-    }
-}
-
-/**
- * 
- * @description 通用两层三元运算符的参数处理，例如
- *              MaxNum: maxNumConverted
-                ? convertNumber(maxNum)
-                : _override
-                    ? (previousServerConfig?.MaxNum)
-                    : 50
- * @param originalParam 原始参数，如 maxNumConverted
- * @param override 是否覆盖，如 _override
- * @param handler 处理参数的函数，如 convertNumber
- * @param overrideVal 如果覆盖，提供的默认覆盖值
- * @param defaultVal 默认值
- * @param args 传入 handler 中使用的额外参数
- */
-export function parseInputParam(originalParam, override: boolean, handler: Function | null, overrideVal, defaultVal, ...args) {
-    return originalParam
-        ? (typeof handler === 'function')
-            ? handler(originalParam, ...args)
-            : originalParam
-        : override
-            ? overrideVal
-            : defaultVal
-}

package/src/utils/config.ts

@@ -1,39 +0,0 @@
-import _ from 'lodash'
-import path from 'path'
-import yargs, { Arguments } from 'yargs'
-import { ConfigParser, ICloudBaseConfig } from '@cloudbase/toolbox'
-
-export interface IArgs {
-    envId: string
-    region: string
-    verbose: boolean
-    configPath: string
-    [x: string]: unknown
-}
-
-export const getArgs = (): Arguments<IArgs> => {
-    // console.log(yargs.argv)
-    return yargs.alias('e', 'envId').alias('r', 'region').argv as any
-}
-
-// 获取 cloudbase 配置
-export const getCloudBaseConfig = async (configPath?: string): Promise<ICloudBaseConfig> => {
-    const args = getArgs()
-
-    let specificConfigPath = configPath || args.configPath
-    specificConfigPath = specificConfigPath ? path.resolve(specificConfigPath) : undefined
-
-    const parser = new ConfigParser({
-        configPath: specificConfigPath
-    })
-    const config: ICloudBaseConfig = await parser.get()
-
-    // 合并默认配置
-    if (config?.functionDefaultConfig && config?.functions?.length) {
-        config.functions = config.functions.map((rawConfig) =>
-            _.merge({}, config.functionDefaultConfig, rawConfig)
-        )
-    }
-
-    return config
-}

package/src/utils/env.ts

@@ -1,244 +0,0 @@
-import _ from 'lodash'
-import open from 'open'
-import { prompt } from 'enquirer'
-import { getDataFromWeb, isCamRefused } from '@cloudbase/toolbox'
-import { CloudBaseError } from '../error'
-import { listEnvs, getEnvInfo } from '../env'
-import { ENV_STATUS, STATUS_TEXT } from '../constant'
-import { CloudApiService, getMangerService } from './net'
-import { execWithLoading } from './output'
-import { logger } from './log'
-
-const tcbService = CloudApiService.getInstance('tcb')
-
-const ENV_INIT_TIP = '环境初始化中，预计需要三分钟'
-const CREATE_ENV = 'CREATE'
-const consoleUrl = 'https://console.cloud.tencent.com/tcb/env/index?action=CreateEnv&from=cli'
-
-/**
- * 展示环境列表选择器，获取用户选择的环境
- */
-export async function getSelectedEnv(inputEnvId?: string) {
-    // 检查是否开通 TCB 服务
-    const isInitNow = await checkTcbService()
-
-    let envData = []
-
-    // 刚初始化服务，新创建的环境还未就绪
-    if (isInitNow) {
-        envData = await execWithLoading(
-            () => {
-                // 等待用户完成创建环境的流程
-                return new Promise((resolve) => {
-                    const timer = setInterval(async () => {
-                        const envs = await listEnvs()
-                        if (envs.length) {
-                            clearInterval(timer)
-                            resolve(envs)
-                        }
-                    }, 2000)
-                })
-            },
-            {
-                startTip: '获取环境列表中'
-            }
-        )
-    } else {
-        // 选择环境
-        envData = await execWithLoading(() => listEnvs(), {
-            startTip: '获取环境列表中'
-        })
-    }
-
-    envData = envData || []
-
-    // 检查输入的环境 Id 是否属于用户
-    if (envData?.length && inputEnvId) {
-        const inputEnvIdExist = envData.find((_) => _.EnvId === inputEnvId)
-        if (!inputEnvIdExist) {
-            throw new CloudBaseError(`你指定的环境 Id ${inputEnvId} 不存在，请指定正确的环境 Id！`)
-        }
-        return inputEnvId
-    }
-
-    // 按名称排序，构造展示数据
-    const envs: { name: string; value: string }[] = envData
-        .map((item) => {
-            let name = `${item.Alias} - [${item.EnvId}:${item.PackageName || '按量计费'}]`
-            if (item.Status !== ENV_STATUS.NORMAL) {
-                name += `（${STATUS_TEXT[item.Status]}）`
-            }
-
-            return {
-                name,
-                value: item.EnvId
-            }
-        })
-        .sort((prev, next) => prev.value.charCodeAt(0) - next.value.charCodeAt(0))
-
-    const choices = [
-        ...envs,
-        {
-            name: envData.length ? '创建新环境' : '无可用环境，创建新环境',
-            value: CREATE_ENV
-        }
-    ]
-
-    let { env } = await prompt<any>({
-        choices,
-        type: 'select',
-        name: 'env',
-        message: '请选择关联环境',
-        result(choice) {
-            return this.map(choice)[choice]
-        }
-    })
-
-    // 创建新环境
-    if (env === CREATE_ENV) {
-        logger.success('已打开控制台，请前往控制台创建环境')
-        // 从控制台获取创建环境生成的 envId
-        const { envId } = await getDataFromWeb((port) => `${consoleUrl}&port=${port}`, 'getData')
-        if (!envId) {
-            throw new CloudBaseError('接收环境 Id 信息失败，请重新运行 init 命令！')
-        }
-        logger.success(`创建环境成功，环境 Id: ${envId}`)
-        env = envId
-    }
-
-    // 检查环境状态
-    await checkEnvStatus(env)
-
-    return env
-}
-
-// 选择地域
-export async function getSelectRegion() {
-    const { region } = await prompt<any>({
-        choices: [
-            {
-                name: '上海',
-                value: 'ap-shanghai'
-            },
-            {
-                name: '广州',
-                value: 'ap-guangzhou'
-            }
-        ],
-        type: 'select',
-        name: 'region',
-        message: '请选择环境所在地域',
-        result(choice) {
-            return this.map(choice)[choice]
-        }
-    })
-
-    tcbService.region = region
-
-    return region
-}
-
-// 检查 TCB 服务是否开通
-export async function checkTcbService(): Promise<boolean> {
-    const app = await getMangerService()
-    let Initialized
-    try {
-        Initialized = (await app.env.checkTcbService()).Initialized
-    } catch (e) {
-        // 忽略 CAM 权限问题
-        if (!isCamRefused(e)) {
-            throw e
-        }
-    }
-
-    if (!Initialized) {
-        const { jump } = await prompt<any>({
-            type: 'confirm',
-            name: 'jump',
-            message:
-                '你还没有开通云开发服务，是否跳转到控制台开通云开发服务？（取消将无法继续操作）',
-            initial: true
-        })
-
-        if (!jump) {
-            throw new CloudBaseError('init 操作终止，请开通云开发服务后再进行操作！')
-        }
-
-        // 打开控制台
-        open(consoleUrl)
-        logger.success('已打开云开发控制台，请登录并在云开发控制台中开通服务！')
-
-        await execWithLoading(() => waitForServiceEnable(), {
-            startTip: '等待云开发服务开通中',
-            successTip: '云开发服务开通成功！'
-        })
-
-        // 返回一个是否刚初始化服务的标志
-        return true
-    }
-
-    return false
-}
-
-// 检查环境的状态，是否可以正常使用
-export async function checkEnvStatus(envId: string) {
-    const env = await getEnvInfo(envId)
-    if (env.Status === ENV_STATUS.UNAVAILABLE) {
-        await checkEnvAvaliable(envId)
-    } else if (env.Status !== ENV_STATUS.NORMAL) {
-        throw new CloudBaseError('所有环境状态异常')
-    }
-}
-
-// 检测环境是否可用
-export async function checkEnvAvaliable(envId: string) {
-    let count = 0
-
-    await execWithLoading(
-        (flush) => {
-            const increase = setInterval(() => {
-                flush(`${ENV_INIT_TIP}  ${++count}S`)
-            }, 1000)
-
-            return new Promise<void>((resolve) => {
-                const timer = setInterval(async () => {
-                    const env = await getEnvInfo(envId)
-                    // 环境初始化中
-                    if (env.Status === ENV_STATUS.NORMAL) {
-                        clearInterval(timer)
-                        clearInterval(increase)
-                        resolve()
-                    }
-                }, 3000)
-            })
-        },
-        {
-            startTip: ENV_INIT_TIP,
-            successTip: `环境 ${envId} 初始化成功`
-        }
-    )
-}
-
-// 等待服务开通
-async function waitForServiceEnable() {
-    return new Promise<void>((resolve) => {
-        const timer = setInterval(async () => {
-            const app = await getMangerService()
-            try {
-                const { Initialized } = await app.env.checkTcbService()
-                if (Initialized) {
-                    clearInterval(timer)
-                    setTimeout(() => {
-                        // 服务初始化完成到环境创建完成有一定的延迟时间，延迟 5S 返回
-                        resolve()
-                    }, 5000)
-                }
-            } catch (e) {
-                // 忽略 CAM 权限问题
-                if (!isCamRefused(e)) {
-                    throw e
-                }
-            }
-        }, 3000)
-    })
-}

package/src/utils/fs/del.ts

@@ -1,5 +0,0 @@
-import del from 'del'
-
-export function delSync(patterns: string | readonly string[]) {
-    del.sync(patterns, { force: true })
-}

package/src/utils/fs/index.ts

@@ -1,71 +0,0 @@
-import fs from 'fs'
-import { CloudBaseError } from '../../error'
-
-export * from './del'
-
-export type SizeUnit = 'KB' | '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 checkWritable(dest: string, throwError = false): boolean {
-    try {
-        // 可见、可写
-        fs.accessSync(dest, fs.constants.F_OK)
-        fs.accessSync(dest, fs.constants.W_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 | string, unit: SizeUnit) {
-    const numSize = Number(size)
-    const unitMap = {
-        KB: 1024,
-        MB: Math.pow(1024, 2),
-        GB: Math.pow(1024, 3)
-    }
-
-    return Number(numSize / unitMap[unit]).toFixed(2)
-}

package/src/utils/function-packer.ts

@@ -1,97 +0,0 @@
-import fs from 'fs'
-import del from 'del'
-import path from 'path'
-import makeDir from 'make-dir'
-import { random } from './tools'
-import { CloudBaseError, zipDir, checkFullAccess } from '@cloudbase/toolbox'
-
-export enum CodeType {
-    File,
-    JavaFile
-}
-
-/**
- * 将函数代码转换成 Base64 编码
- * 普通文件：Node，PHP
- * Java 文件：Jar，ZIP
- */
-export class FunctionPacker {
-    // 项目根目录
-    root: string
-    // 函数名
-    name: string
-    // 代码文件类型
-    type: CodeType
-    funcPath: string
-    funcDistPath: string
-    // 临时目录
-    tmpPath: string
-    // 忽略文件模式
-    ignore: string | string[]
-
-    constructor(root: string, name: string, ignore: string | string[]) {
-        this.name = name
-        this.root = root
-        this.ignore = ignore
-        this.funcPath = path.join(root, name)
-    }
-
-    async getFileCode() {
-        checkFullAccess(this.funcPath, true)
-        // 构建临时文件夹存放函数打包结果
-        this.tmpPath = path.join(this.root, `.cloudbase_tmp_${random()}`)
-        this.funcDistPath = path.join(this.tmpPath, this.name)
-        // 生成存放 zip 文件的文件夹
-        await makeDir(this.funcDistPath)
-        const zipPath = path.resolve(this.funcDistPath, 'dist.zip')
-        // 生成 zip 文件
-
-        await zipDir(this.funcPath, zipPath, this.ignore)
-        // 将 zip 文件转换成 base64
-        const base64 = fs.readFileSync(zipPath).toString('base64')
-        // 清除打包文件
-        this.clean()
-        return base64
-    }
-
-    // 获取 Java 代码
-    getJavaFileCode() {
-        const { funcPath } = this
-        // Java 代码为 jar 或 zip 包
-        const jarExist = checkFullAccess(`${funcPath}.jar`)
-        const zipExist = checkFullAccess(`${funcPath}.zip`)
-        if (!jarExist && !zipExist) {
-            return null
-        }
-        const packagePath = jarExist ? `${funcPath}.jar` : `${funcPath}.zip`
-        return fs.readFileSync(packagePath).toString('base64')
-    }
-
-    async build(type: CodeType) {
-        if (type === CodeType.JavaFile) {
-            try {
-                const code = await this.getJavaFileCode()
-                return code
-            } catch (error) {
-                this.clean()
-                throw new CloudBaseError(`函数代码打包失败：\n ${error.message}`)
-            }
-        }
-
-        if (type === CodeType.File) {
-            try {
-                const code = await this.getFileCode()
-                return code
-            } catch (error) {
-                this.clean()
-                throw new CloudBaseError(`函数代码打包失败：\n ${error.message}`)
-            }
-        }
-    }
-
-    clean() {
-        // allow deleting the current working directory and outside
-        this.funcDistPath && del.sync([this.funcDistPath], { force: true })
-        this.tmpPath && del.sync([this.tmpPath], { force: true })
-    }
-}

package/src/utils/index.ts

@@ -1,25 +0,0 @@
-export * from './net'
-
-export * from './fs'
-export * from './tools'
-export * from './output'
-export * from './platform'
-export * from './reporter'
-export * from './cli-table'
-export * from './progress-bar'
-export * from './function-packer'
-export * from './prompt'
-
-export * from './env'
-export * from './log'
-export * from './template'
-
-export * from './config'
-export * from './auth'
-export * from './store'
-export * from './notice'
-export * from './parallel'
-
-export * from './tcbrApi'
-export * from './checkTcbrEnv'
-export * from './commonParamsCheck'