release 0.0.3-beta source code for nodejs

Author: unionsdk

CHANGELOG.md

@@ -1,3 +1,23 @@
+# 0.0.3-beta 2023-01-06
+
+### G42Cloud SDK IMS
+
+- _Features_
+  - New Support IMS
+- _Bug Fix_
+  - None
+- _Change_
+  - None
+
+### G42Cloud SDK SMN
+
+- _Features_
+  - New Support SMN
+- _Bug Fix_
+  - None
+- _Change_
+  - None
+
 # 0.0.2-beta 2022-11-29
 
 ### G42Cloud SDK CSE

README.md

@@ -1,5 +1,5 @@
 <p align="center">
-<a href="https://www.g42cloud.com/"><img style="background-color:black;" width="450px" height="102px" src="https://auth.g42cloud.com//authui/20220614193554/public/custom/images/logo.svg"></a>
+<a href="https://www.g42cloud.com/"><img src="https://upload.wikimedia.org/wikipedia/en/4/43/Group_42_Logo.jpg"></a>
 </p>
 
 <h1 align="center">G42 Cloud Node.js Software Development Kit (Node.js SDK)</h1>
@@ -23,11 +23,11 @@ This document introduces how to obtain and use G42 Cloud Node.js SDK.
 
 The recommended way to install SDK is with npm.
 
-You must depended on `@huaweicloud/huaweicloud-sdk-core` library no matter which product/service development kit you
+You must depended on `@g42cloud/g42cloud-sdk-core` library no matter which product/service development kit you
 need to use. Take using VPC SDK for example, you need to install `@g42cloud/g42cloud-sdk-vpc` library:
 
 ``` bash
-npm install @huaweicloud/huaweicloud-sdk-core
+npm install @g42cloud/g42cloud-sdk-core
 npm install @g42cloud/g42cloud-sdk-vpc
 ```
 
@@ -39,8 +39,8 @@ npm install @g42cloud/g42cloud-sdk-vpc
 
 ``` javascript
 // index.js
-const core = require('@huaweicloud/huaweicloud-sdk-core');
-const vpc = require('@g42cloud/huaweicloud-sdk-vpc');
+const core = require('@g42cloud/g42cloud-sdk-core');
+const vpc = require('@g42cloud/g42cloud-sdk-vpc');
 
 const ak = '<YOUR AK>';
 const sk = '<YOUR SK>';

core/.mocharc.json

@@ -0,0 +1,7 @@
+{
+  "require": [
+    "ts-node/register",
+    "source-map-support/register"
+  ],
+  "timeout": 3000
+}

core/ClientBuilder.ts

@@ -0,0 +1,182 @@
+/*
+ * Copyright 2020 G42 Technologies Co.,Ltd.
+ *
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+import { HcClient } from "./HcClient";
+import { ICredential } from "./auth/ICredential";
+import { ClientOptions, DefaultHttpClient } from "./http/DefaultHttpClient";
+import { RequiredError } from "./auth/AKSKSigner";
+import { BasicCredentials } from "./auth/BasicCredentials";
+import { GlobalCredentials } from "./auth/GlobalCredentials";
+import { SdkException } from "./exception/SdkException";
+import { Region } from "./region/region";
+import { UserOptions } from "./UserOptions";
+const path = require('path');
+
+interface CredParams {
+    ak?: string;
+    sk?: string,
+    project_id?: string,
+    domain_id?: string,
+}
+export class ClientBuilder<T> {
+    private init: Function;
+    private endpoint?: string;
+    private credential?: ICredential;
+    private proxyAgent?: string;
+    private credentialType: string[] = ["BasicCredentials", "GlobalCredentials"];
+    private envParams: CredParams = process.env;
+    private region?: Region;
+    private userOptions?: UserOptions;
+
+    public constructor(init: (hcClient: HcClient) => T, credentialType?: string) {
+        this.init = init;
+        if (credentialType) {
+            this.credentialType = credentialType.split(",");
+        }
+    }
+
+    public withEndpoint(endpoint: string): ClientBuilder<T> {
+        this.endpoint = endpoint;
+        return this;
+    }
+
+    public withCredential(credential?: ICredential): ClientBuilder<T> {
+        this.credential = credential;
+        return this;
+    }
+
+    public withProxyAgent(proxyAgent: string): ClientBuilder<T> {
+        this.proxyAgent = proxyAgent;
+        return this;
+    }
+
+    public withRegion(region: Region): ClientBuilder<T> {
+        this.region = region;
+        return this;
+    }
+
+    public withOptions(options: UserOptions): ClientBuilder<T> {
+        this.userOptions = options;
+        return this;
+    }
+
+    public build(): T {
+        const axiosOptions: ClientOptions = {
+            disableSslVerification: true
+        };
+        if (this.proxyAgent) {
+            Object.assign(axiosOptions, { proxy: this.proxyAgent });
+        }
+        if (this.userOptions?.customUserAgent) {
+            axiosOptions.headers = axiosOptions.headers || {};
+            axiosOptions.headers["User-Agent"] = this.userOptions.customUserAgent;
+        }
+
+        if (!this.credential) {
+            this.credential = this.getCredentialFromEnvironment();
+        }
+
+        if (!this.credential) {
+            throw new SdkException(`credential can not be null, ${this.credentialType}Credential objects are required`);
+        }
+
+        const client = new DefaultHttpClient(axiosOptions);
+        const hcClient = new HcClient(client);
+        hcClient.withEndpoint(this.endpoint).withCredential(this.credential);
+        if (this.region) {
+            hcClient.withRegion(this.region);
+        }
+        return this.init(hcClient);
+    }
+
+    /**
+     * 从环境变量获取 HUAWEICLOUD_SDK_TYPE 
+     * 环境变量里没有则使用 credentialType[0]
+     * 生成credential实体
+     * 从环境变量获取 AK SK projectId/domainId 进行赋值， 如果环境变量是GlobalCredentials，则赋值domainId
+     * @returns Credentials
+     */
+    public getCredentialFromEnvironment(): ICredential {
+        const sdkType: any = process.env.HUAWEICLOUD_SDK_TYPE;
+        const credentialTYPE = this.whichCredential(sdkType)
+        return this.getInputParamCredential(credentialTYPE, this.envParams);
+    }
+
+    public whichCredential(sdkType: string) {
+        let credentialTYPE;
+        if (sdkType) {
+            switch (sdkType) {
+                case 'BasicCredentials':
+                    credentialTYPE = new BasicCredentials();
+                    break;
+                case 'GlobalCredentials':
+                    credentialTYPE = new GlobalCredentials();
+                    break;
+                default:
+                    const obj = {};
+                    const definedCredPath = path.join(this.init().getPath(), `${sdkType}`);
+                    if (!obj[sdkType]) {
+                        credentialTYPE = require(definedCredPath);
+                        // 多加一层
+                        obj[sdkType] = credentialTYPE[sdkType];
+                    }
+                    credentialTYPE = new obj[sdkType]();
+                    break;
+            }
+        } else {
+            // 默认是basic
+            credentialTYPE = new BasicCredentials();
+        }
+        return credentialTYPE;
+    }
+
+    public getInputParamCredential(CredentialsType: any, credential: CredParams) {
+        // 判断是否有_
+        let hash = {};
+        for (let key in credential) {
+            if (key.indexOf("HUAWEICLOUD_SDK_") == 0) {
+                const value = credential[key]
+                key = key.substring(16);
+                if (key.indexOf('_') == -1) {
+                    key = key.toLowerCase();
+                    key = 'with' + key.charAt(0).toUpperCase() + key.slice(1);
+                } else {
+                    const arr = key.split('_').map(item => {
+                        item = item.toLowerCase();
+                        return item.charAt(0).toUpperCase() + item.slice(1);
+                    })
+                    if (Array.isArray(arr)) {
+                        key = 'with' + arr.join("");
+                    }
+                }
+                hash[key] = value
+            }
+        }
+        credential = hash;
+        for (const key in credential) {
+            if (CredentialsType[key]) {
+                CredentialsType[key](credential[key]);
+            }
+        }
+        return CredentialsType;
+    }
+
+}

core/HcClient.ts

@@ -0,0 +1,146 @@
+/*
+ * Copyright 2020 G42 Technologies Co.,Ltd.
+ *
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+import { HttpClient } from "./http/HttpClient";
+import { ICredential } from "./auth/ICredential";
+import { IHttpRequest } from "./http/IHttpRequest";
+import { HttpRequestBuilder } from "./http/IHttpRequestBuilder";
+import { SdkResponse } from "./SdkResponse";
+import { ExceptionUtil } from "./exception/ExceptionUtil";
+import { getLogger, Logger, LogLevel } from './logger';
+import { DefaultHttpResponse } from "./http/DefaultHttpResponse";
+import { Region } from "./region/region";
+
+export class HcClient {
+    private httpClient: HttpClient;
+    private endpoint: string | undefined;
+    private credential: ICredential | undefined;
+    private proxyAgent: string = '';
+    private static loggerName = 'HcClient';
+    private logger: Logger;
+    region?: Region;
+
+    public constructor(client: HttpClient) {
+        this.httpClient = client;
+
+        // Logging
+        this.logger = getLogger(HcClient.loggerName, LogLevel.INFO);
+        this.logger.debug('initialized');
+    }
+
+    public withEndpoint(endpoint?: string): HcClient {
+        this.endpoint = endpoint;
+        return this;
+    }
+
+    public withCredential(credential?: ICredential): HcClient {
+        this.credential = credential;
+        return this;
+    }
+
+    public withRegion(region?: Region) {
+        this.region = region;
+        return this;
+    }
+
+    public withHttpsAgent(proxyAgent: string) {
+        this.proxyAgent = proxyAgent;
+        return this;
+    }
+    public async sendRequest<T extends SdkResponse>(options: any): Promise<any> {
+        this.logger.debug('send request');
+
+        const request = await this.buildRequest(options);
+        // @ts-ignore
+        return this.httpClient.sendRequest<T>(request).then(res => {
+            return this.extractResponse<T>(res);
+        }, err => {
+            return ExceptionUtil.generalException(err);
+        });
+    }
+
+    private async buildRequest(options: any): Promise<IHttpRequest> {
+        if (this.region) {
+            this.endpoint = this.region.endpoint;
+            this.credential = await this.credential!.processAuthParams(this, this.region.id);
+        }
+
+        let url = this.endpoint + options.url;
+        const pathParams = options.pathParams;
+        Object.keys(pathParams).forEach(x => {
+            url = url.replace("{" + x + "}", pathParams[x]);
+        });
+
+        if (options.method === 'DELETE'
+            && (options.data && (Object.keys(options.data).length <= 0 || options.data.length <= 0))) {
+            delete options.data;
+        }
+
+        if (options.headers && Object.prototype.hasOwnProperty.call(options.headers, "Content-Type")) {
+            delete options.headers['Content-Type'];
+        }
+
+        if (options.contentType) {
+            if (!options.headers) {
+                options.headers = {};
+            }
+            if (options.contentType.toLowerCase().startsWith("application/json")) {
+                // remove charset
+                options.headers['content-type'] = "application/json";
+            } else {
+                options.headers['content-type'] = options.contentType;
+            }
+        }
+
+        const builder = new HttpRequestBuilder();
+        let httpRequest = builder
+            .withEndpoint(url)
+            .withHeaders(options.headers)
+            .withMethod(options.method)
+            .withPathParams(options.pathParams)
+            .withData(options.data)
+            .withQueryParams(options.queryParams)
+            .build();
+
+        // @ts-ignore
+        httpRequest = this.credential.processAuthRequest(httpRequest);
+        if (options['responseHeaders']) {
+            httpRequest['responseHeaders'] = options['responseHeaders'];
+        }
+        httpRequest.proxy = this.proxyAgent;
+        return httpRequest;
+    }
+
+    private extractResponse<T extends SdkResponse>(result: DefaultHttpResponse<T>): T {
+        const headers = result.headers;
+        let contentType = headers['content-type'];
+        contentType = contentType.toLowerCase();
+        if (contentType && (contentType.startsWith('application/octet-stream') || contentType.startsWith("image"))) {
+            return result.data as T;
+        } else {
+            let response = result.data instanceof Object ? result.data : {} as T;
+            let sdkRespone = response as SdkResponse;
+            sdkRespone.httpStatusCode = result.statusCode;
+
+            return response;
+        }
+    }
+}