@cloudbase/cli 1.11.0 → 1.12.2-alpha.1

package/src/commands/functions/alias/getRoute.ts

@@ -0,0 +1,76 @@
+
+import { Command, ICommand } from '../../common'
+import { loadingFactory, printHorizontalTable } from '../../../utils'
+import { getFunctionAliasConfig } from '../../../function'
+import { InjectParams, CmdContext, ArgsParams, ArgsOptions } from '../../../decorators'
+
+
+function parseRoutingConfigValue(expression: string) {
+    const commaIndex = expression.indexOf(',')
+    const valueExpression = expression.substring(commaIndex + 1, expression.length - 1)
+    return valueExpression
+}
+
+@ICommand()
+export class getFunctionRoutingConfig extends Command {
+    get options() {
+        return {
+            cmd: 'fn',
+            childCmd: 'get-route <name>',
+            options: [
+                {
+                    flags: '-e, --envId <envId>',
+                    desc: '环境 Id'
+                }
+            ],
+            desc: '查看函数版本流量配置'
+        }
+    }
+
+    @InjectParams()
+    async execute(@CmdContext() ctx, @ArgsParams() params) {
+        const name = params?.[0]
+
+        const {
+            envId
+        } = ctx
+
+        const loading = loadingFactory()
+        loading.start(`查询函数 [${name}] 版本流量配置中...`)
+
+        const aliasRes = await getFunctionAliasConfig({
+            envId,
+            functionName: name,
+            name: '$DEFAULT'
+        })
+
+        const routingConfig = aliasRes?.RoutingConfig?.AddtionVersionMatchs
+        let finalConfig = []
+        if (routingConfig.length === 1) {
+            finalConfig.push({
+                version: routingConfig[0].Version,
+                value: parseRoutingConfigValue(routingConfig[0].Expression)
+            })
+        } else if (routingConfig.length === 2) {
+            finalConfig.push({
+                version: routingConfig[0].Version,
+                value: parseRoutingConfigValue(routingConfig[0].Expression)
+            }, {
+                version: routingConfig[1].Version,
+                value: 100 - Number(parseRoutingConfigValue(routingConfig[0].Expression))
+            })
+        }
+
+        loading.stop()
+
+        const head: string[] = ['版本', '流量比例']
+
+        const tableData = finalConfig.map((item) => [
+            item.version,
+            item.value
+        ])
+
+        printHorizontalTable(head, tableData)
+
+    }
+}

package/src/commands/functions/alias/index.ts

@@ -0,0 +1,2 @@
+export * from './setRoute'
+export * from './getRoute'

package/src/commands/functions/alias/setRoute.ts

@@ -0,0 +1,82 @@
+
+import { Command, ICommand } from '../../common'
+import { CloudBaseError } from '../../../error'
+import { loadingFactory } from '../../../utils'
+import { setFunctionAliasConfig } from '../../../function'
+import { InjectParams, CmdContext, ArgsParams, ArgsOptions } from '../../../decorators'
+
+
+@ICommand()
+export class setFunctionRoutingConfig extends Command {
+    get options() {
+        return {
+            cmd: 'fn',
+            childCmd: 'config-route <name> <version1> <traffic1> [version2] [traffic2]',
+            options: [
+                {
+                    flags: '-e, --envId <envId>',
+                    desc: '环境 Id'
+                }
+            ],
+            desc: '设置函数版本流量配置'
+        }
+    }
+
+    @InjectParams()
+    async execute(@CmdContext() ctx, @ArgsParams() params) {
+        const name = params?.[0]
+        const version1 = params?.[1]
+        const traffic1 = Number(params?.[2])
+
+        const version2 = params?.[3]
+        const traffic2 = Number(params?.[4])
+
+        // 校验
+
+        // 1. version2 及 traffic2 必须同时存在
+        if ((version2 === undefined && traffic2 !== undefined) || (version2 !== undefined && traffic2 === undefined)) {
+            throw new CloudBaseError('version2 和 traffic2 必须同时设置')
+        }
+
+        if (traffic1 !== undefined && traffic2 !== undefined) {
+            if (traffic1 + traffic2 !== 100) {
+                throw new CloudBaseError('traffic1 和 traffic2 同时设置时，需保证总和 100')
+            }
+        }
+
+        const {
+            envId
+        } = ctx
+
+        const loading = loadingFactory()
+        loading.start(`设置函数 [${name}] 版本流量配置中...`)
+
+        let routingConfigParams = {
+            AddtionVersionMatchs: [{
+                Expression: `[0,${traffic1})`,
+                Key: "invoke.headers.X-Tcb-Route-Key",
+                Method: "range",
+                Version: version1
+            }]
+        }
+
+        if (version2 !== undefined) {
+            routingConfigParams.AddtionVersionMatchs.push({
+                Expression: `[${traffic1},${100})`,
+                Key: "invoke.headers.X-Tcb-Route-Key",
+                Method: "range",
+                Version: version2
+            })
+        }
+
+        await setFunctionAliasConfig({
+            envId,
+            functionName: name,
+            name: '$DEFAULT',
+            functionVersion: '$LATEST',
+            routingConfig: routingConfigParams
+        })
+
+        loading.succeed(`设置函数 [${name}] 版本流量配置成功！`)
+    }
+}

package/src/commands/functions/concurrency/delete.ts

@@ -0,0 +1,45 @@
+
+import { Command, ICommand } from '../../common'
+import { CloudBaseError } from '../../../error'
+import { loadingFactory } from '../../../utils'
+import { deleteProvisionedConcurrencyConfig } from '../../../function'
+import { InjectParams, CmdContext, ArgsParams, ArgsOptions } from '../../../decorators'
+
+
+@ICommand()
+export class deleteProvisionedConcurrency extends Command {
+    get options() {
+        return {
+            cmd: 'fn',
+            childCmd: 'delete-provisioned-concurrency <name> <version>',
+            options: [
+                {
+                    flags: '-e, --envId <envId>',
+                    desc: '环境 Id'
+                }
+            ],
+            desc: '删除函数版本预置并发配置'
+        }
+    }
+
+    @InjectParams()
+    async execute(@CmdContext() ctx, @ArgsParams() params) {
+        const name = params?.[0]
+        const version = params?.[1]
+
+        const {
+            envId
+        } = ctx
+
+        const loading = loadingFactory()
+        loading.start(`删除函数 [${name}] 预置并发配置中...`)
+
+        await deleteProvisionedConcurrencyConfig({
+            envId,
+            functionName: name,
+            qualifier: version
+        })
+
+        loading.succeed(`删除函数 [${name}] 预置并发配置成功！`)
+    }
+}

package/src/commands/functions/concurrency/index.ts

@@ -0,0 +1,3 @@
+export * from './delete'
+export * from './list'
+export * from './set'

package/src/commands/functions/concurrency/list.ts

@@ -0,0 +1,58 @@
+
+import { Command, ICommand } from '../../common'
+import { CloudBaseError } from '../../../error'
+import { loadingFactory, printHorizontalTable } from '../../../utils'
+import { getProvisionedConcurrencyConfig } from '../../../function'
+import { InjectParams, CmdContext, ArgsParams, ArgsOptions } from '../../../decorators'
+import { StatusMap, ConcurrencyTaskStatus } from '../../../constant'
+
+
+@ICommand()
+export class getProvisionedConcurrency extends Command {
+    get options() {
+        return {
+            cmd: 'fn',
+            childCmd: 'get-provisioned-concurrency <name> [version]',
+            options: [
+                {
+                    flags: '-e, --envId <envId>',
+                    desc: '环境 Id'
+                }
+            ],
+            desc: '获取函数版本预置并发配置'
+        }
+    }
+
+    @InjectParams()
+    async execute(@CmdContext() ctx, @ArgsParams() params, @ArgsOptions() options) {
+        const name = params?.[0]
+        const version = params?.[1]
+
+        const {
+            envId
+        } = ctx
+
+        const loading = loadingFactory()
+        loading.start(`拉取函数 [${name}] 预置并发配置中...`)
+
+        const res = await getProvisionedConcurrencyConfig({
+            envId,
+            functionName: name,
+            qualifier: version
+        })
+
+        loading.stop()
+
+        const head: string[] = ['设置并发数', '已完成并发数', '预置任务状态', '状态说明', '版本号']
+
+        const tableData = res.Allocated.map((item) => [
+            item.AllocatedProvisionedConcurrencyNum,
+            item.AvailableProvisionedConcurrencyNum,
+            ConcurrencyTaskStatus[item.Status] || '无',
+            item.StatusReason,
+            item.Qualifier
+        ])
+
+        printHorizontalTable(head, tableData)
+    }
+}

package/src/commands/functions/concurrency/set.ts

@@ -0,0 +1,47 @@
+
+import { Command, ICommand } from '../../common'
+import { CloudBaseError } from '../../../error'
+import { loadingFactory } from '../../../utils'
+import { setProvisionedConcurrencyConfig } from '../../../function'
+import { InjectParams, CmdContext, ArgsParams, ArgsOptions } from '../../../decorators'
+
+
+@ICommand()
+export class setProvisionedConcurrency extends Command {
+    get options() {
+        return {
+            cmd: 'fn',
+            childCmd: 'set-provisioned-concurrency <name> <version> <concurrency>',
+            options: [
+                {
+                    flags: '-e, --envId <envId>',
+                    desc: '环境 Id'
+                }
+            ],
+            desc: '设置函数版本预置并发'
+        }
+    }
+
+    @InjectParams()
+    async execute(@CmdContext() ctx, @ArgsParams() params) {
+        const name = params?.[0]
+        const version = params?.[1]
+        const concurrency = Number(params?.[2] || 0)
+
+        const {
+            envId
+        } = ctx
+
+        const loading = loadingFactory()
+        loading.start(`配置函数 [${name}] 预置并发中...`)
+
+        await setProvisionedConcurrencyConfig({
+            envId,
+            functionName: name,
+            qualifier: version,
+            versionProvisionedConcurrencyNum: concurrency
+        })
+
+        loading.succeed(`配置函数 [${name}] 预置并发成功！`)
+    }
+}

package/src/commands/functions/index.ts

@@ -11,3 +11,6 @@ export * from './trigger-create'
 export * from './trigger-delete'
 export * from './code-update'
 export * from './code-download'
+export * from './version'
+export * from './concurrency'
+export * from './alias'

package/src/commands/functions/list.ts

@@ -3,14 +3,7 @@ import { CloudBaseError } from '../../error'
 import { listFunction } from '../../function'
 import { printHorizontalTable, loadingFactory } from '../../utils'
 import { InjectParams, EnvId, ArgsOptions } from '../../decorators'
-
-const StatusMap = {
-    Active: '部署完成',
-    Creating: '创建中',
-    CreateFailed: '创建失败',
-    Updating: '更新中',
-    UpdateFailed: '更新失败'
-}
+import { StatusMap } from '../../constant'
 
 @ICommand()
 export class ListFunction extends Command {

package/src/commands/functions/version/index.ts

@@ -0,0 +1,2 @@
+export * from './publish'
+export * from './list'

package/src/commands/functions/version/list.ts

@@ -0,0 +1,73 @@
+
+import { Command, ICommand } from '../../common'
+import { CloudBaseError } from '../../../error'
+import { loadingFactory, printHorizontalTable } from '../../../utils'
+import { listFunctionVersions } from '../../../function'
+import { InjectParams, CmdContext, ArgsParams, ArgsOptions } from '../../../decorators'
+import { StatusMap } from '../../../constant'
+
+
+@ICommand()
+export class ListFunctionVersion extends Command {
+    get options() {
+        return {
+            cmd: 'fn',
+            childCmd: 'list-function-versions <name>',
+            options: [
+                {
+                    flags: '-e, --envId <envId>',
+                    desc: '环境 Id'
+                },
+                { flags: '-l, --limit <limit>', desc: '返回数据长度，默认值为 20' },
+                {
+                    flags: '-o, --offset <offset>',
+                    desc: '数据偏移量，默认值为 0'
+                }
+            ],
+            desc: '展示函数版本列表'
+        }
+    }
+
+    @InjectParams()
+    async execute(@CmdContext() ctx, @ArgsParams() params, @ArgsOptions() options) {
+        const name = params?.[0]
+        let { limit = 20, offset = 0 } = options
+        limit = Number(limit)
+        offset = Number(offset)
+        if (!Number.isInteger(limit) || !Number.isInteger(offset)) {
+            throw new CloudBaseError('limit 和 offset 必须为整数')
+        }
+
+        if (limit < 0 || offset < 0) {
+            throw new CloudBaseError('limit 和 offset 必须为大于 0 的整数')
+        }
+
+        const {
+            envId
+        } = ctx
+
+        const loading = loadingFactory()
+        loading.start(`拉取函数 [${name}] 版本列表中...`)
+
+        const res = await listFunctionVersions({
+            envId,
+            functionName: name,
+            offset,
+            limit
+        })
+
+        loading.stop()
+
+        const head: string[] = ['版本', '描述', '创建时间', '修改时间', '状态']
+
+        const tableData = res.Versions.map((item) => [
+            item.Version,
+            item.Description,
+            item.AddTime,
+            item.ModTime,
+            StatusMap[item.Status]
+        ])
+
+        printHorizontalTable(head, tableData)
+    }
+}

package/src/commands/functions/version/publish.ts

@@ -0,0 +1,43 @@
+
+import { Command, ICommand } from '../../common'
+import { CloudBaseError } from '../../../error'
+import { loadingFactory } from '../../../utils'
+import { publishVersion } from '../../../function'
+import { InjectParams, CmdContext, ArgsParams } from '../../../decorators'
+
+@ICommand()
+export class PublishFunctionVersion extends Command {
+    get options() {
+        return {
+            cmd: 'fn',
+            childCmd: 'publish-version <name> [description]',
+            options: [
+                {
+                    flags: '-e, --envId <envId>',
+                    desc: '环境 Id'
+                }
+            ],
+            desc: '发布函数新版本'
+        }
+    }
+
+    @InjectParams()
+    async execute(@CmdContext() ctx, @ArgsParams() params) {
+        const name = params?.[0]
+        const description = params?.[1]
+        const {
+            envId
+        } = ctx
+
+        const loading = loadingFactory()
+        loading.start(`发布函数 [${name}] 新版本中...`)
+
+        await publishVersion({
+            envId,
+            functionName: name,
+            description
+        })
+
+        loading.succeed(`发布函数 [${name}] 新版本成功！`)
+    }
+}

package/src/constant.ts

@@ -68,6 +68,12 @@ export const ALL_COMMANDS = [
     'fn trigger create',
     'fn trigger delete',
     'fn invoke',
+    'fn publish-version',
+    'fn list-function-versions',
+    'fn put-provisioned-concurrency',
+    'fn get-provisioned-concurrency',
+    'fn delete-provisioned-concurrency',
+    'fn config-route',
     'functions run',
     'storage upload',
     'storage download',
@@ -94,3 +100,21 @@ export const ALL_COMMANDS = [
     'run standalonegateway turn on',
     'run standalonegateway turn off',
 ]
+
+export const StatusMap = {
+    Active: '部署完成',
+    Creating: '创建中',
+    CreateFailed: '创建失败',
+    Updating: '更新中',
+    UpdateFailed: '更新失败',
+    Publishing: '函数版本发布中',
+    PublishFailed: '函数版本发布失败',
+    Deleting: '函数删除中',
+    DeleteFailed: '函数删除失败'
+}
+
+export const ConcurrencyTaskStatus = {
+    Done: '已完成',
+    InProgress: '进行中',
+    Failed: '失败'
+}

package/src/function/alias.ts

@@ -0,0 +1,43 @@
+import { CloudBaseError } from '../error'
+import { IUpdateFunctionAliasConfig, IGetFunctionAlias, IGetFunctionAliasRes } from '../types'
+import { getFunctionService } from './base'
+
+// 设置函数流量配置信息（ALIAS 配置）
+export async function setFunctionAliasConfig(options: IUpdateFunctionAliasConfig) {
+    const { envId, functionName, name, functionVersion, description, routingConfig } = options
+
+    const scfService = await getFunctionService(envId)
+
+    try {
+        await scfService.updateFunctionAliasConfig({
+            functionName,
+            name,
+            functionVersion,
+            description,
+            routingConfig
+        })
+    } catch (e) {
+        throw new CloudBaseError(`[${functionName}] 设置函数流量配置失败： ${e.message}`, {
+            code: e.code
+        })
+    }
+}
+
+// 查询函数别名配置信息
+export async function getFunctionAliasConfig(options: IGetFunctionAlias): Promise<IGetFunctionAliasRes> {
+    const { envId, functionName, name } = options
+
+    const scfService = await getFunctionService(envId)
+
+    try {
+        return scfService.getFunctionAlias({
+            functionName,
+            name
+        })
+    } catch (e) {
+        throw new CloudBaseError(`[${functionName}] 查询函数别名配置失败： ${e.message}`, {
+            code: e.code
+        })
+    }
+}
+

package/src/function/concurrency.ts

@@ -0,0 +1,57 @@
+import { CloudBaseError } from '../error'
+import { ISetProvisionedConcurrencyConfig, IGetProvisionedConcurrencyConfig, IGetProvisionedConcurrencyRes, IFunctionVersionsRes } from '../types'
+import { getFunctionService } from './base'
+
+// 设置函数预置并发
+export async function setProvisionedConcurrencyConfig(options: ISetProvisionedConcurrencyConfig) {
+    const { envId, functionName, qualifier, versionProvisionedConcurrencyNum } = options
+
+    const scfService = await getFunctionService(envId)
+
+    try {
+        await scfService.setProvisionedConcurrencyConfig({
+            functionName,
+            qualifier,
+            versionProvisionedConcurrencyNum
+        })
+    } catch (e) {
+        throw new CloudBaseError(`[${functionName}] 设置函数预置并发失败： ${e.message}`, {
+            code: e.code
+        })
+    }
+}
+
+// 查看函数预置并发
+export async function getProvisionedConcurrencyConfig(options: IGetProvisionedConcurrencyConfig): Promise<IGetProvisionedConcurrencyRes> {
+    const { envId, functionName, qualifier } = options
+    const scfService = await getFunctionService(envId)
+
+    try {
+        return scfService.getProvisionedConcurrencyConfig({
+            functionName,
+            qualifier,
+        })
+    } catch (e) {
+        throw new CloudBaseError(`[${functionName}] 查看函数预置并发信息失败： ${e.message}`, {
+            code: e.code
+        })
+    }
+}
+
+// 删除函数预置并发
+export async function deleteProvisionedConcurrencyConfig(options: IGetProvisionedConcurrencyConfig): Promise<void> {
+    const { envId, functionName, qualifier } = options
+    const scfService = await getFunctionService(envId)
+
+    try {
+        await scfService.deleteProvisionedConcurrencyConfig({
+            functionName,
+            qualifier
+        })
+    } catch (e) {
+        throw new CloudBaseError(`[${functionName}] 删除函数预置并发失败： ${e.message}`, {
+            code: e.code
+        })
+    }
+}
+

package/src/function/index.ts

@@ -5,4 +5,7 @@ export * from './base'
 export * from './delete'
 export * from './update'
 export * from './layer'
-export * from './vpc'
+export * from './vpc'
+export * from './version'
+export * from './concurrency'
+export * from './alias'

package/src/function/version.ts

@@ -0,0 +1,39 @@
+import { CloudBaseError } from '../error'
+import { IPublishVersionParams, IListFunctionVersionParams, IFunctionVersionsRes } from '../types'
+import { getFunctionService } from './base'
+
+// 发布云函数新版本
+export async function publishVersion(options: IPublishVersionParams) {
+    const { envId, functionName, description = '' } = options
+
+    const scfService = await getFunctionService(envId)
+
+    try {
+        await scfService.publishVersion({
+            functionName,
+            description
+        })
+    } catch (e) {
+        throw new CloudBaseError(`[${functionName}] 函数发布新版本失败： ${e.message}`, {
+            code: e.code
+        })
+    }
+}
+
+// 查看函数所有版本
+export async function listFunctionVersions(options: IListFunctionVersionParams): Promise<IFunctionVersionsRes> {
+    const { envId, functionName, offset = 0, limit = 20 } = options
+    const scfService = await getFunctionService(envId)
+
+    try {
+        return scfService.listVersionByFunction({
+            functionName,
+            offset,
+            limit
+        })
+    } catch (e) {
+        throw new CloudBaseError(`[${functionName}] 查看寒函数版本列表失败： ${e.message}`, {
+            code: e.code
+        })
+    }
+}