@cloudbase/cli 1.12.7-alpha.4 → 2.0.2

package/src/run/service/common.ts

@@ -0,0 +1,206 @@
+import { CloudApiService, parseOptionalParams, parseInputParam } from '../../utils'
+import { ITcbrServiceOptions, IDescribeWxCloudBaseRunReleaseOrder, ITcbrServiceRequiredOptions } from '../../types'
+import { CloudBaseError } from '@cloudbase/toolbox'
+import { packageDeploy } from './index'
+import { listImage } from '..'
+import { DEFAULT_CPU_MEM_SET } from '../../constant'
+
+const tcbService = CloudApiService.getInstance('tcb')
+
+export async function describeWxCloudBaseRunReleaseOrder(options: IDescribeWxCloudBaseRunReleaseOrder) {
+    const res = await tcbService.request('DescribeWxCloudBaseRunReleaseOrder', {
+        EnvId: options.envId,
+        ServerName: options.serviceName
+    })
+    return res
+}
+
+export const convertNumber = (item) => {
+    if (isNaN(Number(item))) {
+        throw new CloudBaseError(`${item} 必须为数字`)
+    }
+    return Number(item)
+}
+
+export const extractPolicyDetails = (policyDetails: string) => {
+    return policyDetails.split('&').map(condition => {
+        let [type, threshold] = [condition.split('=')[0], Number(condition.split('=')[1])]
+        if (isNaN(threshold) || !['cpu', 'mem'].includes(type)) {
+            throw new CloudBaseError('请输入合法的缩扩容配置')
+        }
+        return {
+            PolicyType: type,
+            PolicyThreshold: threshold
+        }
+    })
+}
+
+export const parseEnvParams = (envParams: string) => {
+    return envParams.split('&').reduce((acc, cur) => {
+        const [key, value] = cur.split('=')
+        acc[key] = value
+        return acc
+    }, {})
+}
+
+/**
+ * @description 合并当前与已有的环境变量，当前传入的环境变量 key 去重并取位置靠后的，如与原有环境变量 key 相同，则替换
+ * @param curEnvParams 当前输入的环境变量
+ * @param preEnvParams 已有的环境变量
+ * @returns 
+ */
+export const mergeEnvParams = (curEnvParams: string, preEnvParams: string) => {
+    const curEnv = parseEnvParams(curEnvParams)
+    const preEnv = preEnvParams ? JSON.parse(preEnvParams) : {}
+    const curEnvKeys = Object.keys(curEnv)
+    Object.entries(preEnv).forEach(([key, value]) => {
+        if (!curEnvKeys.includes(key)) {
+            curEnv[key] = value
+        }
+    })
+    return JSON.stringify(curEnv)
+}
+
+function checkRequiredParams(options: ITcbrServiceRequiredOptions) {
+    if (!options.envId) {
+        throw new CloudBaseError('必须使用 -e 或 --envId 指定环境ID')
+    }
+
+    if (!options.serviceName) {
+        throw new CloudBaseError('必须使用 -s 或 --serviceName 指定服务名')
+    }
+
+    if (!options.containerPort) {
+        throw new CloudBaseError('必须使用 --containerPort 指定监听端口号')
+    }
+
+    if (!options.isCreated && !options.path) {
+        throw new CloudBaseError('请使用 --path 指定代码根目录')
+    }
+
+    if (options.isCreated && !options.path && !options.library_image && !options.image) {
+        throw new CloudBaseError('请使用 --path 指定代码根目录或 --library_image 指定线上镜像 tag ')
+    }
+}
+
+/**
+ * 
+ * @param options 原始用户输入
+ * @param isCreated 服务是否已被创建（未创建的服务不能使用镜像 tag ）
+ * @param defaultOverride 是否默认用上次的服务配置替代缺省值
+ * @param previousServerConfig 上次的服务配置
+ * @returns 
+ */
+export async function tcbrServiceOptions(options: ITcbrServiceOptions, isCreated: boolean, defaultOverride?: boolean, previousServerConfig?) {
+    let {
+        noConfirm: _noConfirm = false,
+        override: _override = (defaultOverride || false),
+        envId,
+        serviceName,
+        path,
+        cpu,
+        mem,
+        minNum,
+        maxNum,
+        policyDetails,
+        customLogs,
+        envParams,
+        containerPort,
+        remark,
+        targetDir,
+        dockerfile,
+        image,
+        library_image,
+        json: _json = false
+    } = options
+
+    // 检查必选参数是否填写
+    checkRequiredParams({
+        envId,
+        serviceName,
+        containerPort,
+        isCreated,
+        path,
+        library_image,
+        image
+    })
+    containerPort = Number(containerPort)
+
+    // 处理用户输入的参数
+    const DeployInfo: any = {
+        DeployType: library_image || image
+            ? 'image'
+            : 'package',
+        DeployRemark: remark || '',
+    }
+    // 可选参数进行校验和转换
+    let {
+        cpuConverted,
+        memConverted,
+        maxNumConverted,
+        minNumConverted
+    } = parseOptionalParams({
+        cpu,
+        mem,
+        maxNum,
+        minNum
+    })
+
+    const newServiceOptions = {
+        ServerName: serviceName,
+        EnvId: envId,
+        ServerConfig: {
+            EnvId: envId,
+            MaxNum: parseInputParam(maxNumConverted, _override, convertNumber, previousServerConfig?.MaxNum, 50),
+            MinNum: parseInputParam(minNumConverted, _override, convertNumber, previousServerConfig?.MinNum, 0),
+            BuildDir: parseInputParam(targetDir, _override, null, previousServerConfig?.BuildDir, '.'),
+            Cpu: parseInputParam(cpuConverted, _override, null, previousServerConfig?.Cpu, 0.5),
+            Mem: parseInputParam(memConverted, _override, null, previousServerConfig?.Mem, 1),
+            OpenAccessTypes: ['PUBLIC'],
+            ServerName: serviceName,
+            InitialDelaySeconds: 2,
+            CustomLogs: parseInputParam(customLogs, _override, null, previousServerConfig?.CustomLogs, 'stdout'),
+            CreateTime: previousServerConfig?.CreateTime || (new Date()).toLocaleString().replace(/\//g, '-'),
+            PolicyDetails: parseInputParam(policyDetails, _override, extractPolicyDetails, previousServerConfig?.PolicyDetails, DEFAULT_CPU_MEM_SET),
+            EnvParams: parseInputParam(envParams, _override, mergeEnvParams, previousServerConfig?.EnvParams, '', previousServerConfig?.EnvParams),
+            Port: containerPort,
+            HasDockerfile: true,
+            Dockerfile: dockerfile || 'Dockerfile',
+        },
+        DeployInfo: {
+            ...DeployInfo
+        }
+    }
+
+    if (DeployInfo.DeployType === 'package') {
+        // 本地上传
+        const { PackageName, PackageVersion } = await packageDeploy({
+            envId,
+            serviceName,
+            filePath: path,
+        })
+        DeployInfo.PackageName = PackageName
+        DeployInfo.PackageVersion = PackageVersion
+    } else if (DeployInfo.DeployType === 'image') {
+        // 拉取镜像
+        const imageList = await listImage({
+            envId,
+            serviceName
+        })
+        if (library_image) {
+            const imageInfo = imageList.find(({ Tag }) => Tag === library_image)
+            if (!imageInfo) {
+                throw new CloudBaseError(`镜像 ${library_image} 不存在`)
+            }
+            DeployInfo.ImageUrl = imageInfo.ImageUrl
+        } else {
+            // 暂时不支持 image 镜像
+            throw new CloudBaseError('暂不支持 --image 参数，请使用 --library_image 指定线上镜像 tag')
+        }
+    }
+
+    newServiceOptions.DeployInfo = {
+        ...DeployInfo
+    }
+    return newServiceOptions
+}

package/src/run/service/config.ts

@@ -0,0 +1,77 @@
+import { describeCloudRunServerDetail } from './create'
+import { ITcbrServiceConfigOptions, IDescribeCloudRunServerDetail } from '../../types'
+import { CloudBaseError } from '@cloudbase/toolbox'
+import { mergeEnvParams, extractPolicyDetails } from './common'
+import { callTcbrApi, parseOptionalParams } from '../../utils'
+
+export async function tcbrServiceConfigOptions(options: ITcbrServiceConfigOptions) {
+    let {
+        serviceName,
+        envId,
+        cpu,
+        mem,
+        minNum,
+        maxNum,
+        policyDetails,
+        customLogs,
+        envParams,
+    } = options
+
+    if (!envId) {
+        throw new CloudBaseError('必须使用 -e 或 --envId 指定环境ID')
+    }
+
+    if (!serviceName) {
+        throw new CloudBaseError('必须使用 -s 或 --serviceName 指定服务名')
+    }
+
+    let {
+        cpuConverted,
+        memConverted,
+        maxNumConverted,
+        minNumConverted
+    } = parseOptionalParams({
+        cpu,
+        mem,
+        maxNum,
+        minNum
+    })
+
+    const serviceInfo = await describeCloudRunServerDetail({
+        envId,
+        serviceName
+    })
+
+    if(serviceInfo instanceof Error && serviceInfo['code'] === 'InvalidParameter') {
+        throw new CloudBaseError('服务不存在，请检查服务名是否正确或用 tcb run service:create 创建服务')
+    }
+
+    const { ServerConfig: previousServerConfig } = serviceInfo.data as IDescribeCloudRunServerDetail
+
+    const newServiceOptions = {
+        EnvId: envId,
+        ServerName: serviceName,
+        OpenAccessTypes: previousServerConfig.OpenAccessTypes,
+        Cpu: cpuConverted || previousServerConfig.Cpu,
+        Mem: memConverted || previousServerConfig.Mem,
+        MinNum: minNumConverted || previousServerConfig.MinNum,
+        MaxNum: maxNumConverted || previousServerConfig.MaxNum,
+        PolicyDetails: policyDetails ? extractPolicyDetails(policyDetails) : previousServerConfig.PolicyDetails,
+        CustomLogs: customLogs || previousServerConfig.CustomLogs,
+        EnvParams: envParams ? mergeEnvParams(envParams, previousServerConfig?.EnvParams) : previousServerConfig.EnvParams,
+        InitialDelaySeconds: 2,
+        CreateTime: previousServerConfig.CreateTime,
+        Port: previousServerConfig.Port,
+        HasDockerfile: true,
+        Dockerfile: previousServerConfig.Dockerfile,
+        BuildDir: previousServerConfig.BuildDir,
+    }
+    return newServiceOptions
+}
+
+export async function updateCloudRunServerConfig(options) {
+    return await callTcbrApi('UpdateCloudRunServerConfig', {
+        EnvId: options.envId,
+        ServerBaseConfig: options.ServerBaseConfig,
+    })
+}

package/src/run/service/create.ts

@@ -0,0 +1,52 @@
+import { callTcbrApi } from '../../utils'
+import { getLogs, tcbrServiceOptions } from '.'
+import inquirer from 'inquirer'
+import { ITcbrServiceOptions } from '../../types'
+import { logger } from '@cloudbase/toolbox'
+
+export const describeCloudRunServerDetail = async (options: { envId: string; serviceName: string }) => {
+    return await callTcbrApi('DescribeCloudRunServerDetail', {
+        EnvId: options.envId,
+        ServerName: options.serviceName,
+    })
+}
+
+export async function createCloudRunServer(serviceConfigOptions) {
+    return callTcbrApi('CreateCloudRunServer', serviceConfigOptions)
+}
+
+export async function createTcbrService(options: ITcbrServiceOptions) {
+    const newServiceOptions = await tcbrServiceOptions(options, false, false)
+
+    if (!options.noConfirm) {
+        const { confirm } = await inquirer.prompt([
+            {
+                type: 'confirm',
+                name: 'confirm',
+                message: '确定要创建服务吗？',
+            }
+        ])
+        if (!confirm) {
+            return
+        }
+    }
+
+    const createRes: any = await createCloudRunServer(newServiceOptions)
+    const taskId = createRes.data?.TaskId
+
+    if (options.json) {
+        console.log(JSON.stringify(createRes, null, 2))
+    }
+
+    // `--verbose` 也用于全局指定参数，因此不能从 options 中获取到
+    if (process.argv.includes('--verbose')) {
+        await getLogs({
+            envId: options.envId,
+            taskId,
+            serviceName: options.serviceName
+        })
+        console.log(`本次任务的 TaskID： ${taskId}`)
+    } else {
+        logger.success('创建服务成功, 本次任务的 TaskID: ' + taskId)
+    }
+}

package/src/run/service/deployPackage.ts

@@ -0,0 +1,65 @@
+import path from 'path'
+import * as fs from 'fs'
+import fetch from 'node-fetch'
+import { createBuild } from '..'
+import { CloudBaseError, execWithLoading, loadingFactory, zipDir } from '@cloudbase/toolbox'
+
+interface IPackageDeploy {
+    envId: string,
+    serviceName: string,
+    filePath: string,
+    fileToIgnore?: string | string[]
+}
+
+export async function packageDeploy(options: IPackageDeploy) {
+    let {
+        envId,
+        serviceName,
+        filePath,
+        fileToIgnore
+    } = options
+    let { PackageName, PackageVersion, UploadUrl } = await createBuild({
+        envId,
+        serviceName
+    })
+
+    const loading = loadingFactory()
+    const zipFile = `.tcbr_${serviceName}_${Date.now()}.zip`
+    const dstPath = path.join(process.cwd(), zipFile)
+
+    try {
+        if(fs.statSync(filePath).isDirectory()) {
+            loading.start('正在压缩文件…')
+            await zipDir(filePath, dstPath, fileToIgnore)
+            loading.succeed('压缩文件完成')
+        } 
+    } catch (error) {
+        if(error.code === 'ENOENT') {
+            throw new CloudBaseError('找不到指定文件夹，请检查文件路径是否正确')
+        } else {
+            throw new CloudBaseError(error.message)
+        }
+    }
+
+    try {
+        return await execWithLoading(
+            async () => {
+                await fetch(UploadUrl, {
+                    method: 'PUT',
+                    body: fs.createReadStream(zipFile),
+                    headers: {
+                        'content-type': 'application/zip'
+                    }
+                })
+                return { PackageName, PackageVersion }
+            },
+            {
+                startTip: '\n正在上传代码包...',
+                failTip: '上传代码包失败，请稍后重试'
+            }
+        )
+    } finally {
+        await fs.promises.unlink(dstPath)
+    }
+
+}

package/src/run/service/index.ts

@@ -0,0 +1,7 @@
+export * from './list'
+export * from './create'
+export * from './showLogs'
+export * from './deployPackage'
+export * from './common'
+export * from './update'
+export * from './config'

package/src/run/service/list.ts

@@ -0,0 +1,29 @@
+import { IServerInfo } from '../../types'
+import { callTcbrApi, CloudApiService } from '../../utils'
+
+const tcbService = CloudApiService.getInstance('tcb')
+
+export const listService = async (options): Promise<IServerInfo[]> => {
+    // 没有 CreateTime 因此需要调用两个接口
+    const { data: { ServerList: serverList } } = await callTcbrApi('DescribeCloudRunServers', {
+        EnvId: options.envId,
+    })
+
+    const { CloudBaseRunServerSet: serverSet} = await tcbService.request('DescribeCloudBaseRunServers', {
+        EnvId: options.envId,
+        Offset: 0,
+        Limit: options.limit || 100
+    })
+
+    // 按照 ServerName 拼接结果
+    if(!serverList.length) return []
+    const serverInfo = serverList.map(serverItem => {
+        return {
+            ...serverItem,
+            CreatedTime: serverSet.find( ( item ) =>  item.ServerName === serverItem.ServerName).CreatedTime
+        }
+    })
+
+    return serverInfo
+
+}

package/src/run/service/showLogs.ts

@@ -0,0 +1,98 @@
+import { callTcbrApi } from '../../utils'
+import { EnumDeployStatus } from '../../constant'
+import chalk from 'chalk'
+
+export async function getBuildStatus(envId: string, serviceName: string) {
+    const { data: deployRes } = await callTcbrApi('DescribeCloudRunDeployRecord', {
+        EnvId: envId,
+        ServerName: serviceName,
+    })
+    if (deployRes?.DeployRecords) {
+        if (deployRes?.DeployRecords[0].Status === EnumDeployStatus.Deploying) {
+            return Promise.resolve('pending')
+        } else {
+            return Promise.resolve('completed')
+        }
+    } else {
+        return Promise.resolve('pending')
+    }
+}
+
+
+async function getBuildId(envId: string, serviceName: string): Promise<number> {
+    const { data: deployRes } = await callTcbrApi('DescribeCloudRunDeployRecord', {
+        EnvId: envId,
+        ServerName: serviceName,
+    })
+    if (deployRes?.DeployRecords) {
+        if (deployRes.DeployRecords[0].Status !== 'deploying') {
+            return Promise.resolve(deployRes.DeployRecords[0].BuildId)
+        }
+    }
+}
+
+async function getRunId(envId: string, serviceName: string) {
+    return new Promise<string>((resolve) => {
+        const timer = setInterval(async () => {
+            const { data: deployRes } = await callTcbrApi('DescribeCloudRunDeployRecord', {
+                EnvId: envId,
+                ServerName: serviceName,
+            })
+            if (deployRes?.DeployRecords) {
+                clearInterval(timer)
+                resolve(deployRes.DeployRecords[0].RunId)
+            }
+        }, 3000)
+    })
+}
+
+
+// 多次获取 processLog
+async function showProcessLogs(envId: string, runId: string, serviceName: string) {
+    return new Promise<void>(resolve => {
+        const timer = setInterval(async () => {
+            if (await getBuildStatus(envId, serviceName) === 'completed') {
+                clearInterval(timer)
+                resolve()
+            } else {
+                const { data: processLogs } = await callTcbrApi('DescribeCloudRunProcessLog', {
+                    EnvId: envId,
+                    RunId: runId,
+                })
+                if (processLogs?.Logs) {
+                    console.log(processLogs?.Logs.join('\n'))
+                }
+            }
+        }, 5000)
+    })
+}
+
+// buildLog 仅在完成后获取一次（未完成 BuildId 为0）
+async function showBuildLogs(envId: string, serviceName: string, serverVersion = '', offset = 0) {
+    const buildId = await getBuildId(envId, serviceName)
+
+    const { data } = await callTcbrApi('DescribeCloudRunBuildLog', {
+        EnvId: envId,
+        BuildId: buildId,
+        ServerName: serviceName,
+        ServerVersion: serverVersion || '',
+        Offset: offset || 0,
+    })
+
+    if (data?.Log?.Text) {
+        console.log(data?.Log?.Text)
+    }
+    return Promise.resolve()
+}
+
+export async function getLogs(options) {
+
+    const runId = await getRunId(options.envId, options.serviceName)
+
+    console.log(chalk.blue('============ 日志开始 ==============='))
+    await showProcessLogs(options.envId, runId, options.serviceName)
+    if (await getBuildStatus(options.envId, options.serviceName) === 'completed') {
+        await showBuildLogs(options.envId, options.serviceName)
+    }
+    console.log(chalk.blue('============ 日志结束 ==============='))
+}

package/src/run/service/update.ts

@@ -0,0 +1,81 @@
+import { CloudBaseError, logger } from '@cloudbase/toolbox'
+import inquirer from 'inquirer'
+import { describeCloudRunServerDetail } from '..'
+import { callTcbrApi } from '../../utils'
+import { tcbrServiceOptions } from './common'
+import { getBuildStatus, getLogs } from './showLogs'
+
+export async function updateCloudRunServer(serviceConfigOptions) {
+    try {
+        const res = await callTcbrApi('UpdateCloudRunServer', serviceConfigOptions)
+        return res
+    } catch (error) {
+        console.log(error)
+    }
+}
+
+export async function updateTcbrService(options) {
+    const { data: serviceDetail } = await describeCloudRunServerDetail({
+        envId: options.envId,
+        serviceName: options.serviceName
+    })
+    if(serviceDetail === undefined) {
+        // 服务不存在
+        throw new CloudBaseError('当前服务不存在，请使用 tcb run service:create 创建服务')
+    }
+    // 查询是否存在发布单
+    /* const { IsExist: isExist } = await describeWxCloudBaseRunReleaseOrder({ 
+                                            envId: options.envId, 
+                                            serviceName: options.serviceName
+                                        })
+    if(isExist) {
+        throw new CloudBaseError('服务正在更新部署，请稍后再试，或查看实时部署日志')
+    } */
+    const status = await getBuildStatus(options.envId, options.serviceName)
+    if(status === 'pending') {
+        throw new CloudBaseError('服务正在更新部署，请稍后再试，或查看实时部署日志')
+    }
+
+    // 获取上次的服务配置信息
+    const previousServerConfig = serviceDetail?.ServerConfig
+
+    const newServiceOptions = await tcbrServiceOptions(options, true, true, previousServerConfig)
+
+    // 二次确认
+    if(!options.noConfirm) {
+        const { confirm } = await inquirer.prompt([
+            {
+                type: 'confirm',
+                name: 'confirm',
+                message: '确定要更新服务吗？',
+            }
+        ])
+        if(!confirm) {
+            return
+        }
+    }
+
+    const updateRes: any = await updateCloudRunServer(newServiceOptions)
+
+    if(updateRes instanceof Error) {
+        // 当前有发布任务在运行中
+        throw new CloudBaseError('当前已有部署发布任务运行中，请稍后再试，或查看实时部署日志')
+    }
+
+    const taskId = updateRes.data?.TaskId
+
+    if(options.json) {
+        console.log(JSON.stringify(updateRes, null, 2))
+    }
+
+    if(process.argv.includes('--verbose')) {
+        await getLogs({
+            envId: options.envId,
+            taskId,
+            serviceName: options.serviceName
+        })
+        console.log(`本次任务的 TaskID： ${taskId}`)
+    } else {
+        logger.success('更新服务成功, 本次任务的 TaskID: ' + taskId)
+    }
+}