release 0.0.5-beta source code for cpp

Author: unionsdk

CHANGELOG.md

@@ -1,4 +1,15 @@
-# 0.0.4-beta # 0.0.4-beta 2023-02-20
+# 0.0.5-beta 2023-04-14
+
+### G42Cloud SDK Core
+
+- _Features_
+  - None
+- _Bug Fix_
+  - None
+- _Change_
+  - Optimize the code structure.
+
+# 0.0.4-beta 2023-02-20
 
 ### G42Cloud SDK IMS
 

README.md

@@ -83,7 +83,13 @@ vcpkg install curl cpprestsdk boost openssl spdlog
 
 5. click `CMakeLists.txt` and choose `Load CMake Project`
 
-6. choose `Build` and start compile
+6. Configure compilation toolchain of clion as MSVC: Select Toolchain as Visual Studio on the `CMake` configuration page in step 3, and you cannot select other compilers such as mingw (the windows platform relies on the msvc compiler,
+   Compiling with other compilers such as mingw will report an error). In addition, the user can also choose whether the compiled binary file is in Debug mode or Release mode, and select `Build Type` to make a drop-down selection.
+ 
+7. Configure the architecture and platform of the target file: the windows platform supports compiling sdk link library files of different CPU architectures (x64, x86), users can configure according to actual needs, click
+   `Build, Execution, Deployment` → `Toolchains`, in the Architecture option, you can drop down to select the supported CPU architecture.
+ 
+8. choose `Build` and start compile
 
 #### Step 3: Install C++ SDK
 
@@ -165,6 +171,27 @@ $ ./vpc_test
 # response
 $
 ```
+If you use cmake to manage projects under Windows, you need to introduce the relevant dependencies of the sdk core package and service package in CMakeLists.txt.
+You can refer to the following CMakeLists.txt file:
+```
+cmake_minimum_required(VERSION 3.16)
+project(demo)
+find_package(CURL REQUIRED)
+set(CMAKE_CXX_STANDARD 14)
+
+set(LINK_DIR "C:/Program Files (x86)/huaweicloud_cpp_sdk_v3/bin;")
+set(BIN_DIR "C:/Program Files (x86)/huaweicloud_cpp_sdk_v3/lib;")
+set(SERVICE_DIR "C:/Program Files (x86)/huaweicloud_cpp_sdk_v3/include;")
+set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -DBOOST_UUID_FORCE_AUTO_LINK")
+
+link_directories(${BIN_DIR})
+include_directories(${SERVICE_DIR})
+add_compile_options("$<$<C_COMPILER_ID:MSVC>:/utf-8>")
+add_compile_options("$<$<CXX_COMPILER_ID:MSVC>:/utf-8>")
+
+add_executable(demo main.cpp)
+target_link_libraries(demo PUBLIC core vpc_v2)
+```
 
 ## Online Debugging
 

core/include/g42cloud/core/Client.h

@@ -93,7 +93,7 @@ class G42CLOUD_CORE_EXPORT Client {
     Region region_;
     HttpClient httpClient_;
 
-    std::atomic<int> endpointIndex = 0;
+    std::atomic<int> endpointIndex;
 };
 }
 }

core/include/g42cloud/core/exception/ClientRequestException.h

@@ -32,6 +32,9 @@ class G42CLOUD_CORE_EXPORT ClientRequestException : public ServiceResponseExcept
     ClientRequestException(int statusCode, const std::string &errorCode, const std::string &errorMsg,
         const std::string &requestId);
 
+    ClientRequestException(int statusCode, const std::string &errorCode, const std::string &errorMsg,
+                           const std::string &requestId, const std::string &encodedAuthorizationMessage);
+
     ClientRequestException(int statusCode, const SdkErrorMessage &sdkErrorMessage);
 };
 }

core/include/g42cloud/core/exception/SdkErrorMessage.h

@@ -34,28 +34,34 @@ class G42CLOUD_CORE_EXPORT SdkErrorMessage {
     explicit SdkErrorMessage(int statusCode);
     SdkErrorMessage(const std::string &errorCode, const std::string &errorMsg, const std::string &requestId);
     SdkErrorMessage(const std::string &errorCode, const std::string &errorMsg);
+    SdkErrorMessage(const std::string &errorCode, const std::string &errorMsg, const std::string &requestId,
+                    const std::string &encodedAuthorizationMessage);
 
     virtual ~SdkErrorMessage();
 
     int getStatusCode() const;
     const std::string &getErrorMsg() const;
     const std::string &getErrorCode() const;
     const std::string &getRequestId() const;
+    const std::string &getEncodedAuthorizationMessage() const;
 
     void setStatusCode(int statusCode);
     void setErrorMsg(const std::string &errorMsg);
     void setErrorCode(const std::string &errorCode);
     void setRequestId(const std::string &requestId);
+    void setEncodedAuthorizationMessage(const std::string &encodedAuthorizationMessage);
 
     SdkErrorMessage &withErrorMsg(const std::string &errorMsg);
     SdkErrorMessage &withErrorCode(const std::string &errorCode);
     SdkErrorMessage &withRequestId(const std::string &requestId);
+    SdkErrorMessage &withEncodedAuthorizationMessage(const std::string &encodedAuthorizationMessage);
 
 private:
     int statusCode_ {};
     std::string errorMsg_;
     std::string errorCode_;
     std::string requestId_;
+    std::string encodedAuthorizationMessage_;
 };
 }
 }

core/include/g42cloud/core/exception/ServiceResponseException.h

@@ -33,20 +33,30 @@ class G42CLOUD_CORE_EXPORT ServiceResponseException : public SdkException {
     ServiceResponseException(int statusCode, const SdkErrorMessage &sdkErrorMessage);
     ServiceResponseException(int statusCode, const std::string &errorCode, const std::string &errorMsg,
         const std::string &requestId);
+
+    ServiceResponseException(int statusCode, const std::string &errorCode, const std::string &errorMsg,
+                             const std::string &requestId, const std::string &encodedAuthorizationMessage);
+
     static ServiceResponseException mapException(int statusCode, const SdkErrorMessage &sdkErrorMessage);
     static ServiceResponseException mapException(int statusCode, const std::string &errorCode,
         const std::string &errorMsg, const std::string &requestId);
 
+    static ServiceResponseException mapException(int statusCode, const std::string &errorCode,
+                                                 const std::string &errorMsg, const std::string &requestId,
+                                                 const std::string &encodedAuthorizationMessage);
+
     int getStatusCode() const;
     const std::string &getErrorMsg() const;
     const std::string &getErrorCode() const;
     const std::string &getRequestId() const;
+    const std::string &getEncodedAuthorizationMessage() const;
 
 private:
     int statusCode_;
     std::string errorMsg_;
     std::string errorCode_;
     std::string requestId_;
+    std::string encodedAuthorizationMessage_;
 
     std::string toIndentedString(int msg);
     std::string toIndentedString(const std::string &msg);

core/src/Client.cpp

@@ -30,7 +30,9 @@ using namespace G42Cloud::Sdk::Core;
 using namespace G42Cloud::Sdk::Core::Auth;
 using namespace G42Cloud::Sdk::Core::Exception;
 
-Client::Client() = default;
+Client::Client() {
+    endpointIndex = 0;
+};
 
 Client::~Client() = default;
 

core/src/exception/ClientRequestException.cpp

@@ -29,4 +29,10 @@ ClientRequestException::ClientRequestException(int statusCode, const SdkErrorMes
 ClientRequestException::ClientRequestException(int statusCode, const std::string &errorCode,
     const std::string &errorMsg, const std::string &requestId)
     : ServiceResponseException(statusCode, errorCode, errorMsg, requestId)
+{}
+
+ClientRequestException::ClientRequestException(int statusCode, const std::string &errorCode,
+                                               const std::string &errorMsg, const std::string &requestId,
+                                               const std::string &encodedAuthorizationMessage)
+        : ServiceResponseException(statusCode, errorCode, errorMsg, requestId, encodedAuthorizationMessage)
 {}

core/src/exception/SdkErrorMessage.cpp

@@ -39,6 +39,14 @@ SdkErrorMessage::SdkErrorMessage(const std::string &errorCode, const std::string
     requestId_ = requestId;
 }
 
+SdkErrorMessage::SdkErrorMessage(const std::string &errorCode, const std::string &errorMsg, const std::string &requestId,
+                const std::string &encodedAuthorizationMessage) {
+    errorCode_ = errorCode;
+    errorMsg_ = errorMsg;
+    requestId_ = requestId;
+    encodedAuthorizationMessage_ = encodedAuthorizationMessage;
+}
+
 SdkErrorMessage::SdkErrorMessage(const std::string &errorCode, const std::string &errorMsg)
 {
     errorCode_ = errorCode;
@@ -67,6 +75,7 @@ void SdkErrorMessage::setErrorMsg(const std::string &errorMsg)
 
 SdkErrorMessage &SdkErrorMessage::withErrorMsg(const std::string &errorMsg)
 {
+    this->errorMsg_ = errorMsg;
     return *this;
 }
 
@@ -82,6 +91,7 @@ void SdkErrorMessage::setErrorCode(const std::string &errorCode)
 
 SdkErrorMessage &SdkErrorMessage::withErrorCode(const std::string &errorCode)
 {
+    this->errorCode_ = errorCode;
     return *this;
 }
 
@@ -97,5 +107,21 @@ void SdkErrorMessage::setRequestId(const std::string &requestId)
 
 SdkErrorMessage &SdkErrorMessage::withRequestId(const std::string &requestId)
 {
+    this->requestId_ = requestId;
+    return *this;
+}
+
+SdkErrorMessage &SdkErrorMessage::withEncodedAuthorizationMessage(const std::string &encodedAuthorizationMessage) {
+    this->encodedAuthorizationMessage_ = encodedAuthorizationMessage;
     return *this;
-}
+}
+
+const std::string& SdkErrorMessage::getEncodedAuthorizationMessage() const {
+    return this->encodedAuthorizationMessage_;
+}
+
+void SdkErrorMessage::setEncodedAuthorizationMessage(const std::string &encodedAuthorizationMessage) {
+    SdkErrorMessage::encodedAuthorizationMessage_ = encodedAuthorizationMessage;
+}
+
+

core/src/exception/ServiceResponseException.cpp

@@ -34,6 +34,7 @@ ServiceResponseException::ServiceResponseException(int statusCode, const SdkErro
     errorMsg_ = sdkErrorMessage.getErrorMsg();
     errorCode_ = sdkErrorMessage.getErrorCode();
     requestId_ = sdkErrorMessage.getRequestId();
+    encodedAuthorizationMessage_ = sdkErrorMessage.getEncodedAuthorizationMessage();
 }
 
 ServiceResponseException::ServiceResponseException(int statusCode, const std::string &errorCode,
@@ -46,11 +47,21 @@ ServiceResponseException::ServiceResponseException(int statusCode, const std::st
     requestId_ = requestId;
 }
 
+ServiceResponseException::ServiceResponseException(int statusCode, const std::string &errorCode, const std::string &errorMsg,
+                         const std::string &requestId, const std::string &encodedAuthorizationMessage)
+        : SdkException(errorMsg.c_str()) {
+    statusCode_ = statusCode;
+    errorMsg_ = errorMsg;
+    errorCode_ = errorCode;
+    requestId_ = requestId;
+    encodedAuthorizationMessage_ = encodedAuthorizationMessage;
+}
+
 ServiceResponseException ServiceResponseException::mapException(int statusCode,
                                                                 const SdkErrorMessage &sdkErrorMessage)
 {
     return mapException(statusCode, sdkErrorMessage.getErrorCode(), sdkErrorMessage.getErrorMsg(),
-        sdkErrorMessage.getRequestId());
+        sdkErrorMessage.getRequestId(), sdkErrorMessage.getEncodedAuthorizationMessage());
 }
 
 ServiceResponseException ServiceResponseException::mapException(int statusCode, const std::string &errorCode,
@@ -65,6 +76,19 @@ ServiceResponseException ServiceResponseException::mapException(int statusCode,
     return ServiceResponseException(statusCode, errorCode, errorMsg, requestId);
 }
 
+ServiceResponseException ServiceResponseException::mapException(int statusCode, const std::string &errorCode,
+                                                                const std::string &errorMsg, const std::string &requestId,
+                                                                const std::string &encodedAuthorizationMessage)
+{
+    if (statusCode >= 400 && statusCode < 499) { // 400,499 statusCode
+        return ClientRequestException(statusCode, errorCode, errorMsg, requestId, encodedAuthorizationMessage);
+    }
+    if (statusCode >= 500 && statusCode < 600) { // 500,600 statusCode
+        return ServerResponseException(statusCode, errorCode, errorMsg, requestId);
+    }
+    return ServiceResponseException(statusCode, errorCode, errorMsg, requestId, encodedAuthorizationMessage);
+}
+
 int ServiceResponseException::getStatusCode() const
 {
     return statusCode_;
@@ -85,6 +109,10 @@ const std::string &ServiceResponseException::getRequestId() const
     return requestId_;
 }
 
+const std::string &ServiceResponseException::getEncodedAuthorizationMessage() const {
+    return encodedAuthorizationMessage_;
+}
+
 std::string ServiceResponseException::toIndentedString(int msg)
 {
     std::stringstream temp;