release 0.0.4-beta source code for cpp

Author: unionsdk

CHANGELOG.md

@@ -1,3 +1,14 @@
+# 0.0.4-beta # 0.0.4-beta 2023-02-20
+
+### G42Cloud SDK IMS
+
+- _Features_
+    - None
+- _Bug Fix_
+    - None
+- _Change_
+    - Add the enum values `IsoImage` to the request parameter `type` to the interface `CreateImage`
+
 # 0.0.3-beta 2023-01-06
 
 ### G42Cloud SDK IMS

core/include/g42cloud/core/Client.h

@@ -22,6 +22,7 @@
 #include <memory>
 #include <curl/curl.h>
 #include <map>
+#include <atomic>
 
 #include <g42cloud/core/RequestParams.h>
 #include <g42cloud/core/utils/Header.h>
@@ -55,17 +56,16 @@ class G42CLOUD_CORE_EXPORT Client {
 
     void setHttpConfig(const HttpConfig &httpConfig);
     void setCredentials(std::unique_ptr<Credentials> credentials);
-    void setEndPoint(std::string endPoint);
     void setStreamLog(bool streamLog);
     void setFileLog(std::string filePath, bool fileLog);
     void setRegion(Region region);
     void setHttpClient(const HttpClient& httpClient);
+    void setEndpoints(const std::vector<std::string> &endpoints);
 
-    std::string getEndpoint();
     Region getRegion();
     bool getStreamLog();
     bool getFileLog();
-
+    const std::vector<std::string> &getEndpoints() const;
     bool isCredentialsEmpty();
 
     void processRegionAuth();
@@ -84,14 +84,16 @@ class G42CLOUD_CORE_EXPORT Client {
         const std::map<std::string, std::string> &updatePathParams);
     std::string getQueryParams(const std::map<std::string, std::string> &map);
 
-    std::string endpoint_;
+    std::vector<std::string> endpoints_;
     std::unique_ptr<Credentials> credentials_;
     HttpConfig httpConfig_;
     bool streamLog_ = false;
     bool fileLog_ = false;
     std::string filePath_;
     Region region_;
     HttpClient httpClient_;
+
+    std::atomic<int> endpointIndex = 0;
 };
 }
 }

core/include/g42cloud/core/ClientBuilder.h

@@ -135,7 +135,11 @@ template <typename T> class G42CLOUD_CORE_EXPORT ClientBuilder {
 
     ClientBuilder &withEndPoint(std::string endPoint)
     {
-        endPoint_ = std::move(endPoint);
+        if (endPoints_.empty()) {
+            endPoints_.emplace_back(endPoint);
+        } else {
+            endPoints_[0] = endPoint;
+        }
         return *this;
     }
 
@@ -177,7 +181,7 @@ template <typename T> class G42CLOUD_CORE_EXPORT ClientBuilder {
         }
         client->setFileLog(std::move(filePath_), fileLog_);
         client->setStreamLog(streamLog_);
-        client->setEndPoint(endPoint_);
+        client->setEndpoints(endPoints_);
         if (region_.getRegionId() != "" && region_.getEndpoint() != "") {
             client->setRegion(region_);
             client->processRegionAuth();
@@ -192,7 +196,7 @@ template <typename T> class G42CLOUD_CORE_EXPORT ClientBuilder {
     std::unique_ptr<HttpConfig> httpConfig_;
     Region region_;
     bool streamLog_ = false;
-    std::string endPoint_;
+    std::vector<std::string> endPoints_;
     std::string filePath_;
     bool fileLog_ = false;
     std::string defaultType_;

core/include/g42cloud/core/auth/Region.h

@@ -20,6 +20,7 @@
 #define G42CLOUD_SDK_CORE_AUTH_REGION_H
 
 #include <string>
+#include <vector>
 #include <g42cloud/core/CoreExport.h>
 
 namespace G42Cloud {
@@ -33,15 +34,19 @@ class G42CLOUD_CORE_EXPORT Region {
 
     Region(const Region& region);
     Region(std::string regionId, std::string endpoint);
+    Region(std::string regionId, std::initializer_list<std::string> endpoints);
 
     Region& withRegionId(std::string regionId);
     Region& withEndpoint(std::string endpoint);
+    Region& withEndpoints(std::vector<std::string> endpoints);
 
     const std::string getEndpoint() const;
     const std::string getRegionId() const;
+
+    std::vector<std::string> getEndpoints() const;
 private:
     std::string regionId_;
-    std::string endpoint_;
+    std::vector<std::string> endpoints_;
 };
 }
 }

core/include/g42cloud/core/http/HttpConfig.h

@@ -80,7 +80,6 @@ class G42CLOUD_CORE_EXPORT HttpConfig {
     int getPoolMaxsize() const;
 
     void setPoolMaxsize(int poolMaxsize);
-
 private:
     std::string proxyProtocol_;
     std::string proxyHost_;
@@ -89,6 +88,7 @@ class G42CLOUD_CORE_EXPORT HttpConfig {
     std::string proxyPassword_;
 
     bool ignoreSslVerification_ = false;
+
     std::string sslCaCert_;
     std::string certFile_;
 

core/src/Client.cpp

@@ -21,68 +21,80 @@
 #include <g42cloud/core/auth/GlobalCredentials.h>
 #include <g42cloud/core/auth/BasicCredentials.h>
 #include <g42cloud/core/http/HttpRequest.h>
+#include <g42cloud/core/utils/ModelBase.h>
+
 #include <boost/algorithm/string/replace.hpp>
 #include <utility>
-#include <g42cloud/core/utils/MultipartFormData.h>
-#include <g42cloud/core/utils/ModelBase.h>
 
 using namespace G42Cloud::Sdk::Core;
 using namespace G42Cloud::Sdk::Core::Auth;
+using namespace G42Cloud::Sdk::Core::Exception;
 
 Client::Client() = default;
 
-Client::~Client() {}
+Client::~Client() = default;
 
 void Client::processRegionAuth() {
+    spdlog::info("[Client]begin execute region auth...");
     const std::string regionId = region_.getRegionId();
     const std::string endPoint = region_.getEndpoint();
-    if (!endPoint.empty()) {
-        this->endpoint_ = endPoint;
-    }
+    const std::vector<std::string>& regionEndpoints = this->region_.getEndpoints();
+    this->endpoints_.insert(this->endpoints_.end(), regionEndpoints.begin(), regionEndpoints.end());
+    spdlog::info("[Client]execute region auth end...");
 }
 
 std::unique_ptr<HttpResponse> Client::callApi(const std::string &method, const std::string &resourcePath,
     const std::map<std::string, std::string> &pathParams, const std::map<std::string, std::string> &queryParams,
-    const std::map<std::string, std::string> &headerParams, const std::string &body)
-{
+    const std::map<std::string, std::string> &headerParams, const std::string &body) {
     std::string scheme;
     std::string host;
 
     spdlog::info("client:call service api {}, resourcePath:{}", method, resourcePath);
     const std::string regionId = this->region_.getRegionId();
     if (!regionId.empty()) {
-        spdlog::info("use region auth, processing...");
+        spdlog::info("begin execute region auth for region:{}", regionId);
         credentials_->regionInit();
         credentials_->processAuthParams(regionId);
-        spdlog::info("region auth sucessfully!");
+        spdlog::info("region auth for region:{} successfully!", regionId);
     }
-
-    parseEndPoint(endpoint_, scheme, host);
-    std::string uriHttp = getResourcePath(resourcePath, pathParams, credentials_->getUpdatePathParams());
-    std::string queryParamsHttp = getQueryParams(queryParams);
-    RequestParams requestParams(method, scheme, host, uriHttp, queryParamsHttp, false, body);
-
-    requestParams.addHeader(Header("User-Agent", "g42cloud-usdk-cpp/3.0"));
-    addHeaderParams(requestParams, headerParams);
-    credentials_->processAuthRequest(requestParams);
-
-    if (handler_request) {
-        handler_request(requestParams);
+    while (true) {
+        parseEndPoint(this->endpoints_[endpointIndex], scheme, host);
+        std::string uriHttp = getResourcePath(resourcePath, pathParams, credentials_->getUpdatePathParams());
+        std::string queryParamsHttp = getQueryParams(queryParams);
+        RequestParams requestParams(method, scheme, host, uriHttp, queryParamsHttp, false, body);
+
+        requestParams.addHeader(Header("User-Agent", "g42cloud-usdk-cpp/3.0"));
+        addHeaderParams(requestParams, headerParams);
+        credentials_->processAuthRequest(requestParams);
+
+        if (handler_request) {
+           handler_request(requestParams);
+        }
+        spdlog::info("begin execute http request for the api....");
+        HttpRequest httpRequest;
+        httpRequest.setUrl(parseUrl(requestParams));
+        httpRequest.setMethod(requestParams.getMethod());
+        httpRequest.setRequestBody(requestParams.getBody());
+        httpRequest.setHeaders(requestParams.getHeaders());
+        httpRequest.setStreamLog(streamLog_);
+        httpRequest.setFileLog(fileLog_);
+        httpRequest.setFilePath(filePath_);
+        try {
+            std::unique_ptr<HttpResponse> httpResponse =
+                httpClient_.doHttpRequestSync(httpRequest, httpConfig_, handler_response);
+            spdlog::info("execute http request for the api successfully, get the response....");
+            return httpResponse;
+        } catch (HostUnreachableException ex) {
+            if (!this->endpoints_.empty() && endpointIndex < this->endpoints_.size() - 1) {
+                spdlog::error("can not resolve host for service,region:{}, error:{}", regionId, ex.what());
+                endpointIndex++;
+            } else {
+               endpointIndex = 0;
+               std::string errorMsg = "can not resolve all endpoints for service in region:!" + regionId;
+               throw HostUnreachableException(errorMsg.c_str());
+            }
+        }
     }
-    spdlog::info("begin execute http request for the api....");
-    HttpRequest httpRequest;
-    httpRequest.setUrl(parseUrl(requestParams));
-    httpRequest.setMethod(requestParams.getMethod());
-    httpRequest.setRequestBody(requestParams.getBody());
-    httpRequest.setHeaders(requestParams.getHeaders());
-    httpRequest.setStreamLog(streamLog_);
-    httpRequest.setFileLog(fileLog_);
-    httpRequest.setFilePath(filePath_);
-
-    std::unique_ptr<HttpResponse> httpResponse =
-            httpClient_.doHttpRequestSync(httpRequest, httpConfig_, handler_response);
-    spdlog::info("execute http request for the api successfully, get the response....");
-    return httpResponse;
 }
 
 std::string Client::parseUrl(const RequestParams &requestParams)
@@ -138,11 +150,6 @@ bool Client::isCredentialsEmpty() {
     return credentials_ == nullptr;
 }
 
-void Client::setEndPoint(std::string endPoint)
-{
-    endpoint_ = std::move(endPoint);
-}
-
 void Client::setStreamLog(bool streamLog)
 {
     streamLog_ = streamLog;
@@ -163,10 +170,6 @@ void Client::setHttpClient(const HttpClient& httpClient) {
     httpClient_ = httpClient;
 }
 
-std::string Client::getEndpoint() {
-    return this->endpoint_;
-}
-
 Region Client::getRegion() {
     return this->region_;
 }
@@ -178,6 +181,14 @@ bool Client::getStreamLog() {
     return this->streamLog_;
 }
 
+const std::vector<std::string> &Client::getEndpoints() const {
+    return endpoints_;
+}
+
+void Client::setEndpoints(const std::vector<std::string> &endpoints) {
+    endpoints_ = endpoints;
+}
+
 void Client::parseEndPoint(const std::string &str, std::string &scheme, std::string &host)
 {
     std::vector<std::string> res;
@@ -200,4 +211,4 @@ void Client::parseEndPoint(const std::string &str, std::string &scheme, std::str
     }
     scheme = res.at(0);
     host = res.at(1);
-}
+}

core/src/auth/Region.cpp

@@ -20,25 +20,47 @@
 #include <g42cloud/core/auth/Region.h>
 using namespace G42Cloud::Sdk::Core::Auth;
 
-Region::Region(std::string regionId, std::string endpoint) :regionId_(regionId), endpoint_(endpoint)
-{}
+Region::Region(std::string regionId, std::string endpoint) :regionId_(regionId) {
+    this->endpoints_.emplace_back(endpoint);
+}
 
-Region::Region(const Region& region) :regionId_(region.getRegionId()), endpoint_(region.getEndpoint())
+Region::Region(const Region& region) :regionId_(region.getRegionId()), endpoints_(region.getEndpoints())
 {}
 
+Region::Region(std::string regionId, std::initializer_list<std::string> endpoints) {
+    this->regionId_ = regionId;
+    for (auto iter = endpoints.begin(); iter != endpoints.end(); iter++) {
+        endpoints_.emplace_back(*iter);
+    }
+}
+
 Region& Region::withRegionId(const std::string regionId) {
     this->regionId_ = regionId;
     return *this;
 }
 
 Region& Region::withEndpoint(const std::string endpoint) {
-    this->endpoint_ = endpoint;
+    if (this->endpoints_.empty()) {
+        this->endpoints_.emplace_back(endpoint);
+    } else {
+        this->endpoints_[0] = endpoint;
+    }
+    return *this;
+}
+
+Region& Region::withEndpoints(std::vector<std::string> endpoints) {
+    this->endpoints_ = endpoints;
     return *this;
 }
 
 const std::string Region::getRegionId() const {
     return this->regionId_;
 }
+
 const std::string Region::getEndpoint() const {
-    return this->endpoint_;
+    return this->endpoints_.empty() ? "" : this->endpoints_.front();
+}
+
+std::vector<std::string> Region::getEndpoints() const {
+    return this->endpoints_;
 }