@cloudbase/cli 1.12.7-alpha.4 → 2.0.2

package/src/utils/tcbrApi/tcbr-cloud-api/error.ts

@@ -0,0 +1,30 @@
+interface Options {
+    exit?: number;
+    original?: Error | undefined;
+    code?: string | number;
+    requestId?: string;
+    action?: string;
+    type?: string;
+}
+
+export class CloudBaseError extends Error {
+    readonly exit: number;
+    readonly message: string;
+    readonly name = 'CloudBaseError';
+    readonly original: Error | undefined;
+    readonly code: string | number;
+    readonly requestId: string;
+    readonly action: string;
+    readonly type: string;
+
+    constructor(message: string, options: Options = {}) {
+      super()
+      const { code = '', action = '', original = null, requestId = '', type } = options
+      this.message = `[${action}]\nRequestId：${requestId}\n${message}`
+      this.original = original
+      this.code = code
+      this.requestId = requestId
+      this.action = action
+      this.type = type
+    }
+}

package/src/utils/tcbrApi/tcbr-cloud-api/index.ts

@@ -0,0 +1 @@
+export * from './cloud-api-service'

package/src/utils/tcbrApi/tcbr-cloud-api/request.ts

@@ -0,0 +1,28 @@
+import { URL } from 'url'
+import _fetch, { RequestInit } from 'node-fetch'
+import { HttpsProxyAgent } from 'https-proxy-agent'
+
+export const nodeFetch = _fetch
+
+// 使用 fetch + 代理
+export async function fetch(url: string, config: RequestInit = {}, proxy = '') {
+    if (proxy) {
+        config.agent = new HttpsProxyAgent(proxy)
+    }
+
+    // 解决中文编码问题
+    const escapeUrl = new URL(url).toString()
+
+    const res = await _fetch(escapeUrl, config)
+    return res.json()
+}
+
+export async function fetchStream(url: string, config: RequestInit = {}, proxy = '') {
+    if (proxy) {
+        config.agent = new HttpsProxyAgent(proxy)
+    }
+
+    const escapeUrl = new URL(url).toString()
+
+    return _fetch(escapeUrl, config)
+}

package/src/utils/tcbrApi/tcbr-cloud-api-request.ts

@@ -0,0 +1,66 @@
+import { getCredentialWithoutCheck, getRegion, Credential, getProxy } from '@cloudbase/toolbox'
+import { CloudApiService as _CloudApiService } from './tcbr-cloud-api/index'
+import { CloudBaseError } from '../../error'
+import { REQUEST_TIMEOUT } from '../../constant'
+
+let commonCredential: Credential
+
+// token 将在 n 分钟内过期
+const isTokenExpired = (credential: Credential, gap = 120) =>
+    credential.accessTokenExpired && Number(credential.accessTokenExpired) < Date.now() + gap * 1000
+
+export class CloudApiService {
+    // 缓存请求实例
+    static serviceCacheMap: Record<string, CloudApiService> = {}
+
+    // 单例模式
+    static getInstance(service: string) {
+        if (CloudApiService.serviceCacheMap?.[service]) {
+            return CloudApiService.serviceCacheMap[service]
+        }
+        const apiService = new CloudApiService(service)
+        CloudApiService.serviceCacheMap[service] = apiService
+        return apiService
+    }
+
+    region: string
+    apiService: _CloudApiService
+
+    constructor(service: string, baseParams?: Record<string, any>, version = '') {
+        // 初始化 API 实例
+        this.apiService = new _CloudApiService({
+            service,
+            version: service === 'tcr' 
+                    ? version 
+                    : service === 'tcbr'
+                    ? '2022-02-17'
+                    :'2019-09-24',
+            baseParams,
+            proxy: getProxy(),
+            timeout: REQUEST_TIMEOUT,
+            getCredential: async () => {
+                // 存在未过期的 token
+                if (commonCredential?.secretId && !isTokenExpired(commonCredential)) {
+                    return commonCredential
+                }
+
+                const credential = await getCredentialWithoutCheck()
+                if (!credential) {
+                    throw new CloudBaseError('无有效身份信息，请使用 cloudbase login 登录')
+                }
+
+                commonCredential = credential
+
+                return {
+                    ...credential,
+                    tokenExpired: Number(credential.accessTokenExpired)
+                }
+            }
+        })
+    }
+
+    async request(action: string, data: Record<string, any> = {}, method: 'POST' | 'GET' = 'POST') {
+        const region = this.region || (await getRegion())
+        return this.apiService.request({ action, data, method, region })
+    }
+}

package/src/utils/validator.ts

@@ -1,33 +1,65 @@
-import { CloudBaseError } from '../error'
-
-type SimpleValue = number | string | boolean
-
-export function assertTruthy(val: SimpleValue | SimpleValue[], errMsg: string) {
-    let ok
-    if (Array.isArray(val)) {
-        ok = val.every(item => Boolean(val))
-    } else {
-        ok = Boolean(val)
-    }
-
-    if (!ok) {
-        throw new CloudBaseError(errMsg)
-    }
-}
-
-export function assertHas(obj: any, prop: string, errMsg): void {
-    if (!obj[prop]) {
-        throw new CloudBaseError(errMsg)
-    }
-}
-
-
-export const validateIp = (ip: string): boolean => {
-    if (Object.prototype.toString.call(ip) !== '[object String]') return false
-    const fields = ip.split('.')
-    if (
-        fields.length !== 4 ||
-        fields.find(item => isNaN(Number(item)) || Number(item) < 0 || Number(item) > 255)
-    ) return false
-    return true
+import { CloudBaseError } from '../error'
+import { CPU_MEM_OPTS } from '../constant'
+import { convertNumber } from '../run'
+
+type SimpleValue = number | string | boolean
+
+export function assertTruthy(val: SimpleValue | SimpleValue[], errMsg: string) {
+    let ok
+    if (Array.isArray(val)) {
+        ok = val.every(item => Boolean(val))
+    } else {
+        ok = Boolean(val)
+    }
+
+    if (!ok) {
+        throw new CloudBaseError(errMsg)
+    }
+}
+
+export function assertHas(obj: any, prop: string, errMsg): void {
+    if (!obj[prop]) {
+        throw new CloudBaseError(errMsg)
+    }
+}
+
+
+export const validateIp = (ip: string): boolean => {
+    if (Object.prototype.toString.call(ip) !== '[object String]') return false
+    const fields = ip.split('.')
+    if (
+        fields.length !== 4 ||
+        fields.find(item => isNaN(Number(item)) || Number(item) < 0 || Number(item) > 255)
+    ) return false
+    return true
+}
+
+// 检查 cpu 和 mem 是否符合约束条件
+export const validateCpuMem = (cpuInput: number | string | undefined, memInput: number | string | undefined): { cpuOutput: number, memOutput: number } => {
+    if (cpuInput !== undefined && memInput !== undefined) {
+        let cpuSet = convertNumber(cpuInput)
+        let memSet = convertNumber(memInput)
+        let validMemSet = CPU_MEM_OPTS.find(({ cpu }) => cpu === cpuSet)
+        if (!validMemSet || !validMemSet.mems.length || !validMemSet.mems.includes(memSet)) {
+            throw new CloudBaseError(`cpu 与 mem 规格不匹配，当前规格：cpu: ${cpuInput}, mem: ${memInput}
+请使用下列规格组合之一：${CPU_MEM_OPTS.map(({ cpu, mems }) => `${cpu}-${mems.join('/')}`).join('，')}`)
+        }
+        return { cpuOutput: cpuSet, memOutput: memSet }
+    }
+    if (cpuInput) {
+        let cpuSet = convertNumber(cpuInput)
+        let validSet = CPU_MEM_OPTS.find(({ cpu }) => cpu === cpuSet)
+        if (!validSet) {
+            throw new CloudBaseError(`不支持当前 cpu 规格，请使用下列 cpu 规格之一：${CPU_MEM_OPTS.map(({ cpu }) => cpu).join('，')}`)
+        }
+        return { cpuOutput: cpuSet, memOutput: CPU_MEM_OPTS.find(({ cpu }) => cpu === cpuSet).mems[0] }
+    }
+    if (memInput) {
+        let memSet = convertNumber(memInput)
+        let validSet = CPU_MEM_OPTS.find(({ mems }) => mems.includes(memSet))
+        if (!validSet) {
+            throw new CloudBaseError(`不支持当前 mem 规格，请使用下列 mem 规格之一：${CPU_MEM_OPTS.map(({ mems }) => mems.join('/')).join('，')}`)
+        }
+        return { cpuOutput: validSet.cpu, memOutput: memSet }
+    }
 }

package/types/commands/run/index.d.ts

@@ -4,3 +4,4 @@ export * from './version';
 export * from './delete';
 export * from './image';
 export * from './standalonegateway';
+export * from './service';

package/types/commands/run/service/config.d.ts

@@ -0,0 +1,14 @@
+import { Command } from '../../common';
+import { Logger } from '../../../decorators';
+export declare class ConfigServiceTcbr extends Command {
+    get options(): {
+        cmd: string;
+        childCmd: string;
+        options: {
+            flags: string;
+            desc: string;
+        }[];
+        desc: string;
+    };
+    execute(options: any, log: Logger): Promise<void>;
+}

package/types/commands/run/service/create.d.ts

@@ -0,0 +1,13 @@
+import { Command } from '../../common';
+export declare class CreateServiceTcbr extends Command {
+    get options(): {
+        cmd: string;
+        childCmd: string;
+        options: {
+            flags: string;
+            desc: string;
+        }[];
+        desc: string;
+    };
+    execute(options: any): Promise<void>;
+}

package/types/commands/run/service/deploy.d.ts

@@ -0,0 +1,13 @@
+import { Command } from '../../common';
+export declare class DeployServiceTcbr extends Command {
+    get options(): {
+        cmd: string;
+        childCmd: string;
+        options: {
+            flags: string;
+            desc: string;
+        }[];
+        desc: string;
+    };
+    execute(options: any): Promise<void>;
+}

package/types/commands/run/service/index.d.ts

@@ -0,0 +1,5 @@
+export * from './list';
+export * from './create';
+export * from './update';
+export * from './deploy';
+export * from './config';

package/types/commands/run/service/list.d.ts

@@ -0,0 +1,13 @@
+import { Command } from '../../common';
+export declare class ListServiceTcbr extends Command {
+    get options(): {
+        cmd: string;
+        childCmd: string;
+        options: {
+            flags: string;
+            desc: string;
+        }[];
+        desc: string;
+    };
+    execute(options: any): Promise<void>;
+}

package/types/commands/run/service/update.d.ts

@@ -0,0 +1,13 @@
+import { Command } from '../../common';
+export declare class UpdateServiceTcbr extends Command {
+    get options(): {
+        cmd: string;
+        childCmd: string;
+        options: {
+            flags: string;
+            desc: string;
+        }[];
+        desc: string;
+    };
+    execute(options: any): Promise<void>;
+}

package/types/constant.d.ts

@@ -45,3 +45,21 @@ export declare const ConcurrencyTaskStatus: {
     InProgress: string;
     Failed: string;
 };
+export declare const enum EnumEnvCheck {
+    EnvFit = 0,
+    EnvNewCmdOld = 1,
+    EnvOldCmdNew = 2
+}
+export declare const enum EnumDeployStatus {
+    Deploying = "deploying",
+    DeploySuccess = "running",
+    DeployFailed = "deploy_failed"
+}
+export declare const CPU_MEM_OPTS: {
+    cpu: number;
+    mems: number[];
+}[];
+export declare const DEFAULT_CPU_MEM_SET: {
+    PolicyType: 'mem' | 'cpu';
+    PolicyThreshold: number;
+}[];

package/types/run/index.d.ts

@@ -5,3 +5,4 @@ export * from './image';
 export * from './delete';
 export * from './repo';
 export * from './standalonegateway';
+export * from './service';

package/types/run/service/common.d.ts

@@ -0,0 +1,32 @@
+import { ITcbrServiceOptions, IDescribeWxCloudBaseRunReleaseOrder } from '../../types';
+export declare function describeWxCloudBaseRunReleaseOrder(options: IDescribeWxCloudBaseRunReleaseOrder): Promise<any>;
+export declare const convertNumber: (item: any) => number;
+export declare const extractPolicyDetails: (policyDetails: string) => {
+    PolicyType: string;
+    PolicyThreshold: number;
+}[];
+export declare const parseEnvParams: (envParams: string) => {};
+export declare const mergeEnvParams: (curEnvParams: string, preEnvParams: string) => string;
+export declare function tcbrServiceOptions(options: ITcbrServiceOptions, isCreated: boolean, defaultOverride?: boolean, previousServerConfig?: any): Promise<{
+    ServerName: string;
+    EnvId: string;
+    ServerConfig: {
+        EnvId: string;
+        MaxNum: any;
+        MinNum: any;
+        BuildDir: any;
+        Cpu: any;
+        Mem: any;
+        OpenAccessTypes: string[];
+        ServerName: string;
+        InitialDelaySeconds: number;
+        CustomLogs: any;
+        CreateTime: any;
+        PolicyDetails: any;
+        EnvParams: any;
+        Port: number;
+        HasDockerfile: boolean;
+        Dockerfile: string;
+    };
+    DeployInfo: any;
+}>;

package/types/run/service/config.d.ts

@@ -0,0 +1,23 @@
+import { ITcbrServiceConfigOptions } from '../../types';
+export declare function tcbrServiceConfigOptions(options: ITcbrServiceConfigOptions): Promise<{
+    EnvId: string;
+    ServerName: string;
+    OpenAccessTypes: string[];
+    Cpu: number;
+    Mem: number;
+    MinNum: number;
+    MaxNum: number;
+    PolicyDetails: {
+        PolicyType: string;
+        PolicyThreshold: number;
+    }[];
+    CustomLogs: string;
+    EnvParams: string;
+    InitialDelaySeconds: number;
+    CreateTime: string;
+    Port: number;
+    HasDockerfile: boolean;
+    Dockerfile: string;
+    BuildDir: string;
+}>;
+export declare function updateCloudRunServerConfig(options: any): Promise<any>;

package/types/run/service/create.d.ts

@@ -0,0 +1,7 @@
+import { ITcbrServiceOptions } from '../../types';
+export declare const describeCloudRunServerDetail: (options: {
+    envId: string;
+    serviceName: string;
+}) => Promise<any>;
+export declare function createCloudRunServer(serviceConfigOptions: any): Promise<any>;
+export declare function createTcbrService(options: ITcbrServiceOptions): Promise<void>;

package/types/run/service/deployPackage.d.ts

@@ -0,0 +1,11 @@
+interface IPackageDeploy {
+    envId: string;
+    serviceName: string;
+    filePath: string;
+    fileToIgnore?: string | string[];
+}
+export declare function packageDeploy(options: IPackageDeploy): Promise<{
+    PackageName: any;
+    PackageVersion: any;
+}>;
+export {};

package/types/run/service/index.d.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/types/run/service/list.d.ts

@@ -0,0 +1,2 @@
+import { IServerInfo } from '../../types';
+export declare const listService: (options: any) => Promise<IServerInfo[]>;

package/types/run/service/showLogs.d.ts

@@ -0,0 +1,2 @@
+export declare function getBuildStatus(envId: string, serviceName: string): Promise<string>;
+export declare function getLogs(options: any): Promise<void>;

package/types/run/service/update.d.ts

@@ -0,0 +1,2 @@
+export declare function updateCloudRunServer(serviceConfigOptions: any): Promise<any>;
+export declare function updateTcbrService(options: any): Promise<void>;

package/types/types.d.ts

@@ -325,8 +325,8 @@ export interface IListBranch {
 export interface IListImage {
     envId: string;
     serviceName: string;
-    limit: number;
-    offset: number;
+    limit?: number;
+    offset?: number;
 }
 export interface IDeleteImage {
     envId: string;
@@ -458,3 +458,117 @@ export interface IGetFunctionAliasRes {
     AddTime: string;
     ModTime: string;
 }
+export interface ITcbrServerBaseConfig {
+    EnvId: string;
+    ServerName: string;
+    OpenAccessTypes: string[];
+    Cpu: number;
+    Mem: number;
+    MinNum: number;
+    MaxNum: number;
+    PolicyDetails: {
+        PolicyType: string;
+        PolicyThreshold: number;
+    }[];
+    CustomLogs: string;
+    EnvParams: string;
+    InitialDelaySeconds: number;
+    CreateTime: string;
+    Port: number;
+    HasDockerfile: boolean;
+    Dockerfile: string;
+    BuildDir: string;
+}
+export interface IDescribeCloudRunServerDetail {
+    BaseInfo: {
+        ServerName: string;
+        DefaultDomainName: string;
+        CustomDomainName: string;
+        Status: 'running' | 'deploying' | 'deploy_failed';
+        UpdateTime: string;
+    };
+    ServerConfig: ITcbrServerBaseConfig;
+    RequestId: string;
+}
+export interface ITcbrServiceOptions {
+    noConfirm: boolean;
+    override: boolean;
+    defaultOverride: boolean;
+    envId: string;
+    serviceName: string;
+    path: string;
+    cpu: number;
+    mem: number;
+    minNum: number;
+    maxNum: number;
+    policyDetails: string;
+    customLogs: string;
+    envParams: string;
+    containerPort: number;
+    remark: string;
+    targetDir: string;
+    dockerfile: string;
+    image: string;
+    library_image: string;
+    json: boolean;
+}
+export interface ICloudRunProcessLog {
+    EnvId: string;
+    RunId: string;
+}
+export interface ICloudRunBuildLog {
+    EnvId: string;
+    ServerName: string;
+    ServerVersion: string;
+    BuildId: number;
+    Offset: number;
+}
+export interface IDescribeWxCloudBaseRunReleaseOrder {
+    envId: string;
+    serviceName: string;
+}
+export interface IGetLogs {
+    envId: string;
+    taskId: number;
+    serviceName: string;
+}
+export interface ITcbrServiceConfigOptions {
+    serviceName: string;
+    envId: string;
+    cpu: number;
+    mem: number;
+    minNum: number;
+    maxNum: number;
+    policyDetails: string;
+    customLogs: string;
+    envParams: string;
+}
+export interface IServerInfo {
+    ServerName: string;
+    DefaultDomainName: string;
+    CustomDomainName: string;
+    Status: string;
+    UpdateTime: string;
+    CreatedTime: string;
+}
+export interface ITcbrServiceRequiredOptions {
+    envId: string;
+    serviceName: string;
+    containerPort: number;
+    isCreated: boolean;
+    path: string;
+    library_image: string;
+    image: string;
+}
+export interface ITcbrServiceOptionalOptions {
+    cpu: number | string;
+    mem: number | string;
+    maxNum: number | string;
+    minNum: number | string;
+}
+export interface ITcbrServiceConvertedOptionalOptions {
+    cpuConverted: number;
+    memConverted: number;
+    maxNumConverted: number;
+    minNumConverted: number;
+}

package/types/utils/checkTcbrEnv.d.ts

@@ -0,0 +1,3 @@
+import { EnumEnvCheck } from '../constant';
+export declare function checkTcbrEnv(envId: string | undefined, isTcbr: boolean): Promise<EnumEnvCheck> | never;
+export declare function logEnvCheck(envId: string, warningType: EnumEnvCheck): void;

package/types/utils/commonParamsCheck.d.ts

@@ -0,0 +1,3 @@
+import { ITcbrServiceOptionalOptions, ITcbrServiceConvertedOptionalOptions } from '../types';
+export declare function parseOptionalParams(options: ITcbrServiceOptionalOptions): ITcbrServiceConvertedOptionalOptions;
+export declare function parseInputParam(originalParam: any, override: boolean, handler: Function | null, overrideVal: any, defaultVal: any, ...args: any[]): any;

package/types/utils/index.d.ts

@@ -16,3 +16,6 @@ export * from './auth';
 export * from './store';
 export * from './notice';
 export * from './parallel';
+export * from './tcbrApi';
+export * from './checkTcbrEnv';
+export * from './commonParamsCheck';

package/types/utils/tcbrApi/callTcbrApi.d.ts

@@ -0,0 +1 @@
+export declare function callTcbrApi(action: string, data: Record<string, any>): Promise<any>;

package/types/utils/tcbrApi/index.d.ts

@@ -0,0 +1 @@
+export * from './callTcbrApi';

package/types/utils/tcbrApi/tcbr-cloud-api/cloud-api-service.d.ts

@@ -0,0 +1,51 @@
+import { fetch as _fetch, fetchStream as _fetchStream } from './request';
+export interface ServiceOptions {
+    service: string;
+    version?: string;
+    proxy?: string;
+    timeout?: number;
+    region?: string;
+    baseParams?: Record<string, any>;
+    credential?: Credential;
+    getCredential?: () => Promise<Credential> | Credential;
+}
+export interface Credential {
+    secretId: string;
+    secretKey: string;
+    token?: string;
+    tokenExpired?: number;
+}
+export interface RequestOptions {
+    action: string;
+    data?: Record<string, any>;
+    method?: 'POST' | 'GET';
+    region?: string;
+}
+export declare const fetch: typeof _fetch;
+export declare const fetchStream: typeof _fetchStream;
+export declare const nodeFetch: typeof import("node-fetch").default;
+export declare class CloudApiService {
+    static serviceCacheMap: Record<string, CloudApiService>;
+    static getInstance(options: ServiceOptions): CloudApiService;
+    service: string;
+    version: string;
+    proxy: string;
+    timeout: number;
+    region: string;
+    credential: Credential;
+    baseParams: Record<string, any>;
+    getCredential: () => Promise<Credential> | Credential;
+    url: string;
+    host: string;
+    action: string;
+    method: 'POST' | 'GET';
+    data: Record<string, any>;
+    payload: Record<string, any>;
+    constructor(options: ServiceOptions);
+    get baseUrl(): any;
+    request(options: RequestOptions): any;
+    request(action: string, data?: Record<string, any>, method?: 'POST' | 'GET'): any;
+    requestWithSign(region: any): Promise<any>;
+    getRequestSign(timestamp: number): string;
+    clearCredentialCache(): void;
+}

package/types/utils/tcbrApi/tcbr-cloud-api/error.d.ts

@@ -0,0 +1,20 @@
+interface Options {
+    exit?: number;
+    original?: Error | undefined;
+    code?: string | number;
+    requestId?: string;
+    action?: string;
+    type?: string;
+}
+export declare class CloudBaseError extends Error {
+    readonly exit: number;
+    readonly message: string;
+    readonly name = "CloudBaseError";
+    readonly original: Error | undefined;
+    readonly code: string | number;
+    readonly requestId: string;
+    readonly action: string;
+    readonly type: string;
+    constructor(message: string, options?: Options);
+}
+export {};