From 973d0d3250aed4a7e0a998a62c85cc8288127437 Mon Sep 17 00:00:00 2001 From: sdk-team Date: Wed, 20 Nov 2019 19:32:05 +0800 Subject: [PATCH] Generated 2018-04-12 for EHPC. --- CHANGELOG | 3 + VERSION | 2 +- ehpc/CMakeLists.txt | 32 ++ ehpc/include/alibabacloud/ehpc/EHPCClient.h | 64 ++++ .../alibabacloud/ehpc/model/AddNodesRequest.h | 3 + .../model/BindAccountToClusterUserRequest.h | 63 ++++ .../model/BindAccountToClusterUserResult.h | 49 +++ .../ehpc/model/CreateClusterRequest.h | 5 +- .../ehpc/model/GetAccountingReportRequest.h | 3 + .../ehpc/model/GetAccountingReportResult.h | 4 +- .../ehpc/model/GetAutoScaleConfigResult.h | 1 + .../ehpc/model/GetInstanceReportRequest.h | 60 ++++ .../ehpc/model/GetInstanceReportResult.h | 53 ++++ .../ehpc/model/GetJobReportRequest.h | 63 ++++ .../ehpc/model/GetJobReportResult.h | 53 ++++ .../ehpc/model/GetTotalQueueReportRequest.h | 57 ++++ .../ehpc/model/GetTotalQueueReportResult.h | 53 ++++ .../ehpc/model/GetTotalUserReportRequest.h | 57 ++++ .../ehpc/model/GetTotalUserReportResult.h | 53 ++++ .../ehpc/model/GetWorkbenchTokenRequest.h | 69 ++++ .../ehpc/model/GetWorkbenchTokenResult.h | 64 ++++ .../ehpc/model/ListAccountMappingRequest.h | 51 +++ .../ehpc/model/ListAccountMappingResult.h | 57 ++++ .../ListFileSystemWithMountTargetsResult.h | 9 +- .../alibabacloud/ehpc/model/MountNFSRequest.h | 3 + .../ehpc/model/SetAutoScaleConfigRequest.h | 3 +- .../model/UnbindAccountToClusterUserRequest.h | 57 ++++ .../model/UnbindAccountToClusterUserResult.h | 49 +++ .../ehpc/model/UpdateClusterVolumesRequest.h | 2 +- ehpc/src/EHPCClient.cc | 294 +++++++++++++++++- ehpc/src/model/AddContainerAppRequest.cc | 4 +- ehpc/src/model/AddLocalNodesRequest.cc | 4 +- ehpc/src/model/AddNodesRequest.cc | 15 +- ehpc/src/model/AddQueueRequest.cc | 4 +- ehpc/src/model/AddUsersRequest.cc | 17 +- .../model/BindAccountToClusterUserRequest.cc | 95 ++++++ .../model/BindAccountToClusterUserResult.cc | 44 +++ ehpc/src/model/CreateClusterRequest.cc | 64 ++-- ehpc/src/model/CreateGWSClusterRequest.cc | 4 +- ehpc/src/model/CreateGWSImageRequest.cc | 4 +- ehpc/src/model/CreateGWSInstanceRequest.cc | 4 +- ehpc/src/model/CreateHybridClusterRequest.cc | 41 ++- ehpc/src/model/CreateJobFileRequest.cc | 4 +- ehpc/src/model/CreateJobTemplateRequest.cc | 4 +- ehpc/src/model/DeleteClusterRequest.cc | 4 +- ehpc/src/model/DeleteContainerAppsRequest.cc | 13 +- ehpc/src/model/DeleteGWSClusterRequest.cc | 4 +- ehpc/src/model/DeleteGWSInstanceRequest.cc | 4 +- ehpc/src/model/DeleteImageRequest.cc | 4 +- ehpc/src/model/DeleteJobTemplatesRequest.cc | 4 +- ehpc/src/model/DeleteJobsRequest.cc | 4 +- ehpc/src/model/DeleteNodesRequest.cc | 13 +- ehpc/src/model/DeleteQueueRequest.cc | 4 +- ehpc/src/model/DeleteUsersRequest.cc | 13 +- .../model/DescribeAutoScaleConfigRequest.cc | 4 +- ehpc/src/model/DescribeClusterRequest.cc | 4 +- ehpc/src/model/DescribeContainerAppRequest.cc | 4 +- ehpc/src/model/DescribeGWSClustersRequest.cc | 4 +- ehpc/src/model/DescribeGWSImagesRequest.cc | 4 +- ehpc/src/model/DescribeGWSInstancesRequest.cc | 4 +- .../DescribeImageGatewayConfigRequest.cc | 4 +- ehpc/src/model/DescribeImagePriceRequest.cc | 4 +- ehpc/src/model/DescribeImageRequest.cc | 4 +- ehpc/src/model/DescribeJobRequest.cc | 4 +- .../model/DescribeNFSClientStatusRequest.cc | 4 +- ehpc/src/model/DescribePriceRequest.cc | 25 +- ehpc/src/model/EditJobTemplateRequest.cc | 4 +- ehpc/src/model/GetAccountingReportRequest.cc | 15 +- ehpc/src/model/GetAccountingReportResult.cc | 7 +- ehpc/src/model/GetAutoScaleConfigRequest.cc | 4 +- ehpc/src/model/GetAutoScaleConfigResult.cc | 2 + ehpc/src/model/GetCloudMetricLogsRequest.cc | 4 +- .../model/GetCloudMetricProfilingRequest.cc | 4 +- ehpc/src/model/GetClusterVolumesRequest.cc | 4 +- ehpc/src/model/GetGWSConnectTicketRequest.cc | 4 +- .../model/GetHybridClusterConfigRequest.cc | 4 +- ehpc/src/model/GetInstanceReportRequest.cc | 84 +++++ ehpc/src/model/GetInstanceReportResult.cc | 59 ++++ ehpc/src/model/GetJobReportRequest.cc | 95 ++++++ ehpc/src/model/GetJobReportResult.cc | 59 ++++ ehpc/src/model/GetTotalQueueReportRequest.cc | 73 +++++ ehpc/src/model/GetTotalQueueReportResult.cc | 59 ++++ ehpc/src/model/GetTotalUserReportRequest.cc | 73 +++++ ehpc/src/model/GetTotalUserReportResult.cc | 59 ++++ .../model/GetVisualServiceStatusRequest.cc | 4 +- ehpc/src/model/GetWorkbenchTokenRequest.cc | 117 +++++++ ehpc/src/model/GetWorkbenchTokenResult.cc | 63 ++++ ehpc/src/model/InstallNFSClientRequest.cc | 4 +- ehpc/src/model/InstallSoftwareRequest.cc | 4 +- ehpc/src/model/InvokeShellCommandRequest.cc | 13 +- ehpc/src/model/ListAccountMappingRequest.cc | 51 +++ ehpc/src/model/ListAccountMappingResult.cc | 61 ++++ .../src/model/ListAvailableEcsTypesRequest.cc | 4 +- .../ListAvailableFileSystemTypesRequest.cc | 4 +- .../model/ListCloudMetricProfilingsRequest.cc | 4 +- ehpc/src/model/ListClusterLogsRequest.cc | 4 +- ehpc/src/model/ListClustersMetaRequest.cc | 4 +- ehpc/src/model/ListClustersRequest.cc | 4 +- ehpc/src/model/ListCommandsRequest.cc | 4 +- ehpc/src/model/ListContainerAppsRequest.cc | 4 +- ehpc/src/model/ListContainerImagesRequest.cc | 4 +- ehpc/src/model/ListCpfsFileSystemsRequest.cc | 4 +- .../model/ListCurrentClientVersionRequest.cc | 4 +- ehpc/src/model/ListCustomImagesRequest.cc | 4 +- .../ListFileSystemWithMountTargetsRequest.cc | 4 +- .../ListFileSystemWithMountTargetsResult.cc | 12 +- ehpc/src/model/ListImagesRequest.cc | 4 +- .../src/model/ListInstalledSoftwareRequest.cc | 4 +- .../src/model/ListInvocationResultsRequest.cc | 13 +- ehpc/src/model/ListInvocationStatusRequest.cc | 4 +- ehpc/src/model/ListJobTemplatesRequest.cc | 4 +- ehpc/src/model/ListJobsRequest.cc | 4 +- ehpc/src/model/ListNodesByQueueRequest.cc | 4 +- ehpc/src/model/ListNodesNoPagingRequest.cc | 4 +- ehpc/src/model/ListNodesRequest.cc | 4 +- .../src/model/ListPreferredEcsTypesRequest.cc | 4 +- ehpc/src/model/ListQueuesRequest.cc | 4 +- ehpc/src/model/ListRegionsRequest.cc | 4 +- ehpc/src/model/ListSoftwaresRequest.cc | 4 +- ehpc/src/model/ListUsersRequest.cc | 4 +- ehpc/src/model/ListVolumesRequest.cc | 4 +- .../model/ModifyClusterAttributesRequest.cc | 4 +- .../ModifyContainerAppAttributesRequest.cc | 4 +- .../model/ModifyImageGatewayConfigRequest.cc | 17 +- ehpc/src/model/ModifyUserGroupsRequest.cc | 15 +- ehpc/src/model/ModifyUserPasswordsRequest.cc | 15 +- .../model/ModifyVisualServicePasswdRequest.cc | 4 +- ehpc/src/model/MountNFSRequest.cc | 15 +- ehpc/src/model/PullImageRequest.cc | 4 +- .../model/QueryServicePackAndPriceRequest.cc | 4 +- ehpc/src/model/RecoverClusterRequest.cc | 4 +- ehpc/src/model/RerunJobsRequest.cc | 4 +- ehpc/src/model/ResetNodesRequest.cc | 13 +- .../model/RunCloudMetricProfilingRequest.cc | 4 +- ehpc/src/model/SetAutoScaleConfigRequest.cc | 34 +- ehpc/src/model/SetGWSInstanceUserRequest.cc | 4 +- ehpc/src/model/SetJobUserRequest.cc | 4 +- ehpc/src/model/SetQueueRequest.cc | 13 +- ehpc/src/model/StartClusterRequest.cc | 4 +- ehpc/src/model/StartGWSInstanceRequest.cc | 4 +- ehpc/src/model/StartNodesRequest.cc | 13 +- ehpc/src/model/StartVisualServiceRequest.cc | 4 +- ehpc/src/model/StopClusterRequest.cc | 4 +- ehpc/src/model/StopGWSInstanceRequest.cc | 4 +- ehpc/src/model/StopJobsRequest.cc | 4 +- ehpc/src/model/StopNodesRequest.cc | 13 +- ehpc/src/model/StopVisualServiceRequest.cc | 4 +- ehpc/src/model/SubmitJobRequest.cc | 4 +- .../UnbindAccountToClusterUserRequest.cc | 73 +++++ .../model/UnbindAccountToClusterUserResult.cc | 44 +++ ehpc/src/model/UninstallSoftwareRequest.cc | 4 +- ehpc/src/model/UpdateClusterVolumesRequest.cc | 33 +- ehpc/src/model/UpdateQueueConfigRequest.cc | 4 +- ehpc/src/model/UpgradeClientRequest.cc | 4 +- 154 files changed, 2955 insertions(+), 270 deletions(-) create mode 100644 ehpc/include/alibabacloud/ehpc/model/BindAccountToClusterUserRequest.h create mode 100644 ehpc/include/alibabacloud/ehpc/model/BindAccountToClusterUserResult.h create mode 100644 ehpc/include/alibabacloud/ehpc/model/GetInstanceReportRequest.h create mode 100644 ehpc/include/alibabacloud/ehpc/model/GetInstanceReportResult.h create mode 100644 ehpc/include/alibabacloud/ehpc/model/GetJobReportRequest.h create mode 100644 ehpc/include/alibabacloud/ehpc/model/GetJobReportResult.h create mode 100644 ehpc/include/alibabacloud/ehpc/model/GetTotalQueueReportRequest.h create mode 100644 ehpc/include/alibabacloud/ehpc/model/GetTotalQueueReportResult.h create mode 100644 ehpc/include/alibabacloud/ehpc/model/GetTotalUserReportRequest.h create mode 100644 ehpc/include/alibabacloud/ehpc/model/GetTotalUserReportResult.h create mode 100644 ehpc/include/alibabacloud/ehpc/model/GetWorkbenchTokenRequest.h create mode 100644 ehpc/include/alibabacloud/ehpc/model/GetWorkbenchTokenResult.h create mode 100644 ehpc/include/alibabacloud/ehpc/model/ListAccountMappingRequest.h create mode 100644 ehpc/include/alibabacloud/ehpc/model/ListAccountMappingResult.h create mode 100644 ehpc/include/alibabacloud/ehpc/model/UnbindAccountToClusterUserRequest.h create mode 100644 ehpc/include/alibabacloud/ehpc/model/UnbindAccountToClusterUserResult.h create mode 100644 ehpc/src/model/BindAccountToClusterUserRequest.cc create mode 100644 ehpc/src/model/BindAccountToClusterUserResult.cc create mode 100644 ehpc/src/model/GetInstanceReportRequest.cc create mode 100644 ehpc/src/model/GetInstanceReportResult.cc create mode 100644 ehpc/src/model/GetJobReportRequest.cc create mode 100644 ehpc/src/model/GetJobReportResult.cc create mode 100644 ehpc/src/model/GetTotalQueueReportRequest.cc create mode 100644 ehpc/src/model/GetTotalQueueReportResult.cc create mode 100644 ehpc/src/model/GetTotalUserReportRequest.cc create mode 100644 ehpc/src/model/GetTotalUserReportResult.cc create mode 100644 ehpc/src/model/GetWorkbenchTokenRequest.cc create mode 100644 ehpc/src/model/GetWorkbenchTokenResult.cc create mode 100644 ehpc/src/model/ListAccountMappingRequest.cc create mode 100644 ehpc/src/model/ListAccountMappingResult.cc create mode 100644 ehpc/src/model/UnbindAccountToClusterUserRequest.cc create mode 100644 ehpc/src/model/UnbindAccountToClusterUserResult.cc diff --git a/CHANGELOG b/CHANGELOG index 2365074e6..b98e44919 100644 --- a/CHANGELOG +++ b/CHANGELOG @@ -1,3 +1,6 @@ +2019-11-20 Version 1.36.187 +- Generated 2018-04-12 for `EHPC`. + 2019-11-20 Version 1.36.186 - Supported ecsDemand CreateDemand, ModifyDemand, DeleteDemand API. - Modify ecsDemand DescribesDemands API. diff --git a/VERSION b/VERSION index 1c4e7c625..13532a99c 100644 --- a/VERSION +++ b/VERSION @@ -1 +1 @@ -1.36.186 \ No newline at end of file +1.36.187 \ No newline at end of file diff --git a/ehpc/CMakeLists.txt b/ehpc/CMakeLists.txt index 47e5ee7fa..4d3907b74 100644 --- a/ehpc/CMakeLists.txt +++ b/ehpc/CMakeLists.txt @@ -31,6 +31,8 @@ set(ehpc_public_header_model include/alibabacloud/ehpc/model/AddQueueResult.h include/alibabacloud/ehpc/model/AddUsersRequest.h include/alibabacloud/ehpc/model/AddUsersResult.h + include/alibabacloud/ehpc/model/BindAccountToClusterUserRequest.h + include/alibabacloud/ehpc/model/BindAccountToClusterUserResult.h include/alibabacloud/ehpc/model/CreateClusterRequest.h include/alibabacloud/ehpc/model/CreateClusterResult.h include/alibabacloud/ehpc/model/CreateGWSClusterRequest.h @@ -105,14 +107,26 @@ set(ehpc_public_header_model include/alibabacloud/ehpc/model/GetGWSConnectTicketResult.h include/alibabacloud/ehpc/model/GetHybridClusterConfigRequest.h include/alibabacloud/ehpc/model/GetHybridClusterConfigResult.h + include/alibabacloud/ehpc/model/GetInstanceReportRequest.h + include/alibabacloud/ehpc/model/GetInstanceReportResult.h + include/alibabacloud/ehpc/model/GetJobReportRequest.h + include/alibabacloud/ehpc/model/GetJobReportResult.h + include/alibabacloud/ehpc/model/GetTotalQueueReportRequest.h + include/alibabacloud/ehpc/model/GetTotalQueueReportResult.h + include/alibabacloud/ehpc/model/GetTotalUserReportRequest.h + include/alibabacloud/ehpc/model/GetTotalUserReportResult.h include/alibabacloud/ehpc/model/GetVisualServiceStatusRequest.h include/alibabacloud/ehpc/model/GetVisualServiceStatusResult.h + include/alibabacloud/ehpc/model/GetWorkbenchTokenRequest.h + include/alibabacloud/ehpc/model/GetWorkbenchTokenResult.h include/alibabacloud/ehpc/model/InstallNFSClientRequest.h include/alibabacloud/ehpc/model/InstallNFSClientResult.h include/alibabacloud/ehpc/model/InstallSoftwareRequest.h include/alibabacloud/ehpc/model/InstallSoftwareResult.h include/alibabacloud/ehpc/model/InvokeShellCommandRequest.h include/alibabacloud/ehpc/model/InvokeShellCommandResult.h + include/alibabacloud/ehpc/model/ListAccountMappingRequest.h + include/alibabacloud/ehpc/model/ListAccountMappingResult.h include/alibabacloud/ehpc/model/ListAvailableEcsTypesRequest.h include/alibabacloud/ehpc/model/ListAvailableEcsTypesResult.h include/alibabacloud/ehpc/model/ListAvailableFileSystemTypesRequest.h @@ -223,6 +237,8 @@ set(ehpc_public_header_model include/alibabacloud/ehpc/model/StopVisualServiceResult.h include/alibabacloud/ehpc/model/SubmitJobRequest.h include/alibabacloud/ehpc/model/SubmitJobResult.h + include/alibabacloud/ehpc/model/UnbindAccountToClusterUserRequest.h + include/alibabacloud/ehpc/model/UnbindAccountToClusterUserResult.h include/alibabacloud/ehpc/model/UninstallSoftwareRequest.h include/alibabacloud/ehpc/model/UninstallSoftwareResult.h include/alibabacloud/ehpc/model/UpdateClusterVolumesRequest.h @@ -244,6 +260,8 @@ set(ehpc_src src/model/AddQueueResult.cc src/model/AddUsersRequest.cc src/model/AddUsersResult.cc + src/model/BindAccountToClusterUserRequest.cc + src/model/BindAccountToClusterUserResult.cc src/model/CreateClusterRequest.cc src/model/CreateClusterResult.cc src/model/CreateGWSClusterRequest.cc @@ -318,14 +336,26 @@ set(ehpc_src src/model/GetGWSConnectTicketResult.cc src/model/GetHybridClusterConfigRequest.cc src/model/GetHybridClusterConfigResult.cc + src/model/GetInstanceReportRequest.cc + src/model/GetInstanceReportResult.cc + src/model/GetJobReportRequest.cc + src/model/GetJobReportResult.cc + src/model/GetTotalQueueReportRequest.cc + src/model/GetTotalQueueReportResult.cc + src/model/GetTotalUserReportRequest.cc + src/model/GetTotalUserReportResult.cc src/model/GetVisualServiceStatusRequest.cc src/model/GetVisualServiceStatusResult.cc + src/model/GetWorkbenchTokenRequest.cc + src/model/GetWorkbenchTokenResult.cc src/model/InstallNFSClientRequest.cc src/model/InstallNFSClientResult.cc src/model/InstallSoftwareRequest.cc src/model/InstallSoftwareResult.cc src/model/InvokeShellCommandRequest.cc src/model/InvokeShellCommandResult.cc + src/model/ListAccountMappingRequest.cc + src/model/ListAccountMappingResult.cc src/model/ListAvailableEcsTypesRequest.cc src/model/ListAvailableEcsTypesResult.cc src/model/ListAvailableFileSystemTypesRequest.cc @@ -436,6 +466,8 @@ set(ehpc_src src/model/StopVisualServiceResult.cc src/model/SubmitJobRequest.cc src/model/SubmitJobResult.cc + src/model/UnbindAccountToClusterUserRequest.cc + src/model/UnbindAccountToClusterUserResult.cc src/model/UninstallSoftwareRequest.cc src/model/UninstallSoftwareResult.cc src/model/UpdateClusterVolumesRequest.cc diff --git a/ehpc/include/alibabacloud/ehpc/EHPCClient.h b/ehpc/include/alibabacloud/ehpc/EHPCClient.h index 42d15d859..455ec04e3 100644 --- a/ehpc/include/alibabacloud/ehpc/EHPCClient.h +++ b/ehpc/include/alibabacloud/ehpc/EHPCClient.h @@ -32,6 +32,8 @@ #include "model/AddQueueResult.h" #include "model/AddUsersRequest.h" #include "model/AddUsersResult.h" +#include "model/BindAccountToClusterUserRequest.h" +#include "model/BindAccountToClusterUserResult.h" #include "model/CreateClusterRequest.h" #include "model/CreateClusterResult.h" #include "model/CreateGWSClusterRequest.h" @@ -106,14 +108,26 @@ #include "model/GetGWSConnectTicketResult.h" #include "model/GetHybridClusterConfigRequest.h" #include "model/GetHybridClusterConfigResult.h" +#include "model/GetInstanceReportRequest.h" +#include "model/GetInstanceReportResult.h" +#include "model/GetJobReportRequest.h" +#include "model/GetJobReportResult.h" +#include "model/GetTotalQueueReportRequest.h" +#include "model/GetTotalQueueReportResult.h" +#include "model/GetTotalUserReportRequest.h" +#include "model/GetTotalUserReportResult.h" #include "model/GetVisualServiceStatusRequest.h" #include "model/GetVisualServiceStatusResult.h" +#include "model/GetWorkbenchTokenRequest.h" +#include "model/GetWorkbenchTokenResult.h" #include "model/InstallNFSClientRequest.h" #include "model/InstallNFSClientResult.h" #include "model/InstallSoftwareRequest.h" #include "model/InstallSoftwareResult.h" #include "model/InvokeShellCommandRequest.h" #include "model/InvokeShellCommandResult.h" +#include "model/ListAccountMappingRequest.h" +#include "model/ListAccountMappingResult.h" #include "model/ListAvailableEcsTypesRequest.h" #include "model/ListAvailableEcsTypesResult.h" #include "model/ListAvailableFileSystemTypesRequest.h" @@ -224,6 +238,8 @@ #include "model/StopVisualServiceResult.h" #include "model/SubmitJobRequest.h" #include "model/SubmitJobResult.h" +#include "model/UnbindAccountToClusterUserRequest.h" +#include "model/UnbindAccountToClusterUserResult.h" #include "model/UninstallSoftwareRequest.h" #include "model/UninstallSoftwareResult.h" #include "model/UpdateClusterVolumesRequest.h" @@ -256,6 +272,9 @@ namespace AlibabaCloud typedef Outcome AddUsersOutcome; typedef std::future AddUsersOutcomeCallable; typedef std::function&)> AddUsersAsyncHandler; + typedef Outcome BindAccountToClusterUserOutcome; + typedef std::future BindAccountToClusterUserOutcomeCallable; + typedef std::function&)> BindAccountToClusterUserAsyncHandler; typedef Outcome CreateClusterOutcome; typedef std::future CreateClusterOutcomeCallable; typedef std::function&)> CreateClusterAsyncHandler; @@ -367,9 +386,24 @@ namespace AlibabaCloud typedef Outcome GetHybridClusterConfigOutcome; typedef std::future GetHybridClusterConfigOutcomeCallable; typedef std::function&)> GetHybridClusterConfigAsyncHandler; + typedef Outcome GetInstanceReportOutcome; + typedef std::future GetInstanceReportOutcomeCallable; + typedef std::function&)> GetInstanceReportAsyncHandler; + typedef Outcome GetJobReportOutcome; + typedef std::future GetJobReportOutcomeCallable; + typedef std::function&)> GetJobReportAsyncHandler; + typedef Outcome GetTotalQueueReportOutcome; + typedef std::future GetTotalQueueReportOutcomeCallable; + typedef std::function&)> GetTotalQueueReportAsyncHandler; + typedef Outcome GetTotalUserReportOutcome; + typedef std::future GetTotalUserReportOutcomeCallable; + typedef std::function&)> GetTotalUserReportAsyncHandler; typedef Outcome GetVisualServiceStatusOutcome; typedef std::future GetVisualServiceStatusOutcomeCallable; typedef std::function&)> GetVisualServiceStatusAsyncHandler; + typedef Outcome GetWorkbenchTokenOutcome; + typedef std::future GetWorkbenchTokenOutcomeCallable; + typedef std::function&)> GetWorkbenchTokenAsyncHandler; typedef Outcome InstallNFSClientOutcome; typedef std::future InstallNFSClientOutcomeCallable; typedef std::function&)> InstallNFSClientAsyncHandler; @@ -379,6 +413,9 @@ namespace AlibabaCloud typedef Outcome InvokeShellCommandOutcome; typedef std::future InvokeShellCommandOutcomeCallable; typedef std::function&)> InvokeShellCommandAsyncHandler; + typedef Outcome ListAccountMappingOutcome; + typedef std::future ListAccountMappingOutcomeCallable; + typedef std::function&)> ListAccountMappingAsyncHandler; typedef Outcome ListAvailableEcsTypesOutcome; typedef std::future ListAvailableEcsTypesOutcomeCallable; typedef std::function&)> ListAvailableEcsTypesAsyncHandler; @@ -544,6 +581,9 @@ namespace AlibabaCloud typedef Outcome SubmitJobOutcome; typedef std::future SubmitJobOutcomeCallable; typedef std::function&)> SubmitJobAsyncHandler; + typedef Outcome UnbindAccountToClusterUserOutcome; + typedef std::future UnbindAccountToClusterUserOutcomeCallable; + typedef std::function&)> UnbindAccountToClusterUserAsyncHandler; typedef Outcome UninstallSoftwareOutcome; typedef std::future UninstallSoftwareOutcomeCallable; typedef std::function&)> UninstallSoftwareAsyncHandler; @@ -576,6 +616,9 @@ namespace AlibabaCloud AddUsersOutcome addUsers(const Model::AddUsersRequest &request)const; void addUsersAsync(const Model::AddUsersRequest& request, const AddUsersAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; AddUsersOutcomeCallable addUsersCallable(const Model::AddUsersRequest& request) const; + BindAccountToClusterUserOutcome bindAccountToClusterUser(const Model::BindAccountToClusterUserRequest &request)const; + void bindAccountToClusterUserAsync(const Model::BindAccountToClusterUserRequest& request, const BindAccountToClusterUserAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; + BindAccountToClusterUserOutcomeCallable bindAccountToClusterUserCallable(const Model::BindAccountToClusterUserRequest& request) const; CreateClusterOutcome createCluster(const Model::CreateClusterRequest &request)const; void createClusterAsync(const Model::CreateClusterRequest& request, const CreateClusterAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; CreateClusterOutcomeCallable createClusterCallable(const Model::CreateClusterRequest& request) const; @@ -687,9 +730,24 @@ namespace AlibabaCloud GetHybridClusterConfigOutcome getHybridClusterConfig(const Model::GetHybridClusterConfigRequest &request)const; void getHybridClusterConfigAsync(const Model::GetHybridClusterConfigRequest& request, const GetHybridClusterConfigAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; GetHybridClusterConfigOutcomeCallable getHybridClusterConfigCallable(const Model::GetHybridClusterConfigRequest& request) const; + GetInstanceReportOutcome getInstanceReport(const Model::GetInstanceReportRequest &request)const; + void getInstanceReportAsync(const Model::GetInstanceReportRequest& request, const GetInstanceReportAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; + GetInstanceReportOutcomeCallable getInstanceReportCallable(const Model::GetInstanceReportRequest& request) const; + GetJobReportOutcome getJobReport(const Model::GetJobReportRequest &request)const; + void getJobReportAsync(const Model::GetJobReportRequest& request, const GetJobReportAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; + GetJobReportOutcomeCallable getJobReportCallable(const Model::GetJobReportRequest& request) const; + GetTotalQueueReportOutcome getTotalQueueReport(const Model::GetTotalQueueReportRequest &request)const; + void getTotalQueueReportAsync(const Model::GetTotalQueueReportRequest& request, const GetTotalQueueReportAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; + GetTotalQueueReportOutcomeCallable getTotalQueueReportCallable(const Model::GetTotalQueueReportRequest& request) const; + GetTotalUserReportOutcome getTotalUserReport(const Model::GetTotalUserReportRequest &request)const; + void getTotalUserReportAsync(const Model::GetTotalUserReportRequest& request, const GetTotalUserReportAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; + GetTotalUserReportOutcomeCallable getTotalUserReportCallable(const Model::GetTotalUserReportRequest& request) const; GetVisualServiceStatusOutcome getVisualServiceStatus(const Model::GetVisualServiceStatusRequest &request)const; void getVisualServiceStatusAsync(const Model::GetVisualServiceStatusRequest& request, const GetVisualServiceStatusAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; GetVisualServiceStatusOutcomeCallable getVisualServiceStatusCallable(const Model::GetVisualServiceStatusRequest& request) const; + GetWorkbenchTokenOutcome getWorkbenchToken(const Model::GetWorkbenchTokenRequest &request)const; + void getWorkbenchTokenAsync(const Model::GetWorkbenchTokenRequest& request, const GetWorkbenchTokenAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; + GetWorkbenchTokenOutcomeCallable getWorkbenchTokenCallable(const Model::GetWorkbenchTokenRequest& request) const; InstallNFSClientOutcome installNFSClient(const Model::InstallNFSClientRequest &request)const; void installNFSClientAsync(const Model::InstallNFSClientRequest& request, const InstallNFSClientAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; InstallNFSClientOutcomeCallable installNFSClientCallable(const Model::InstallNFSClientRequest& request) const; @@ -699,6 +757,9 @@ namespace AlibabaCloud InvokeShellCommandOutcome invokeShellCommand(const Model::InvokeShellCommandRequest &request)const; void invokeShellCommandAsync(const Model::InvokeShellCommandRequest& request, const InvokeShellCommandAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; InvokeShellCommandOutcomeCallable invokeShellCommandCallable(const Model::InvokeShellCommandRequest& request) const; + ListAccountMappingOutcome listAccountMapping(const Model::ListAccountMappingRequest &request)const; + void listAccountMappingAsync(const Model::ListAccountMappingRequest& request, const ListAccountMappingAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; + ListAccountMappingOutcomeCallable listAccountMappingCallable(const Model::ListAccountMappingRequest& request) const; ListAvailableEcsTypesOutcome listAvailableEcsTypes(const Model::ListAvailableEcsTypesRequest &request)const; void listAvailableEcsTypesAsync(const Model::ListAvailableEcsTypesRequest& request, const ListAvailableEcsTypesAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; ListAvailableEcsTypesOutcomeCallable listAvailableEcsTypesCallable(const Model::ListAvailableEcsTypesRequest& request) const; @@ -864,6 +925,9 @@ namespace AlibabaCloud SubmitJobOutcome submitJob(const Model::SubmitJobRequest &request)const; void submitJobAsync(const Model::SubmitJobRequest& request, const SubmitJobAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; SubmitJobOutcomeCallable submitJobCallable(const Model::SubmitJobRequest& request) const; + UnbindAccountToClusterUserOutcome unbindAccountToClusterUser(const Model::UnbindAccountToClusterUserRequest &request)const; + void unbindAccountToClusterUserAsync(const Model::UnbindAccountToClusterUserRequest& request, const UnbindAccountToClusterUserAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; + UnbindAccountToClusterUserOutcomeCallable unbindAccountToClusterUserCallable(const Model::UnbindAccountToClusterUserRequest& request) const; UninstallSoftwareOutcome uninstallSoftware(const Model::UninstallSoftwareRequest &request)const; void uninstallSoftwareAsync(const Model::UninstallSoftwareRequest& request, const UninstallSoftwareAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; UninstallSoftwareOutcomeCallable uninstallSoftwareCallable(const Model::UninstallSoftwareRequest& request) const; diff --git a/ehpc/include/alibabacloud/ehpc/model/AddNodesRequest.h b/ehpc/include/alibabacloud/ehpc/model/AddNodesRequest.h index bce803ccf..b517419a9 100644 --- a/ehpc/include/alibabacloud/ehpc/model/AddNodesRequest.h +++ b/ehpc/include/alibabacloud/ehpc/model/AddNodesRequest.h @@ -49,6 +49,8 @@ namespace AlibabaCloud void setSystemDiskSize(int systemDiskSize); std::string getInstanceType()const; void setInstanceType(const std::string& instanceType); + std::string getHostNamePrefix()const; + void setHostNamePrefix(const std::string& hostNamePrefix); std::string getComputeSpotPriceLimit()const; void setComputeSpotPriceLimit(const std::string& computeSpotPriceLimit); int getAutoRenewPeriod()const; @@ -82,6 +84,7 @@ namespace AlibabaCloud std::string systemDiskType_; int systemDiskSize_; std::string instanceType_; + std::string hostNamePrefix_; std::string computeSpotPriceLimit_; int autoRenewPeriod_; int period_; diff --git a/ehpc/include/alibabacloud/ehpc/model/BindAccountToClusterUserRequest.h b/ehpc/include/alibabacloud/ehpc/model/BindAccountToClusterUserRequest.h new file mode 100644 index 000000000..944e4f2ee --- /dev/null +++ b/ehpc/include/alibabacloud/ehpc/model/BindAccountToClusterUserRequest.h @@ -0,0 +1,63 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed 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. + */ + +#ifndef ALIBABACLOUD_EHPC_MODEL_BINDACCOUNTTOCLUSTERUSERREQUEST_H_ +#define ALIBABACLOUD_EHPC_MODEL_BINDACCOUNTTOCLUSTERUSERREQUEST_H_ + +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace EHPC + { + namespace Model + { + class ALIBABACLOUD_EHPC_EXPORT BindAccountToClusterUserRequest : public RpcServiceRequest + { + + public: + BindAccountToClusterUserRequest(); + ~BindAccountToClusterUserRequest(); + + std::string getUserPwd()const; + void setUserPwd(const std::string& userPwd); + std::string getClusterId()const; + void setClusterId(const std::string& clusterId); + std::string getAccessKeyId()const; + void setAccessKeyId(const std::string& accessKeyId); + std::string getAccountName()const; + void setAccountName(const std::string& accountName); + std::string getAccountUid()const; + void setAccountUid(const std::string& accountUid); + std::string getUserName()const; + void setUserName(const std::string& userName); + + private: + std::string userPwd_; + std::string clusterId_; + std::string accessKeyId_; + std::string accountName_; + std::string accountUid_; + std::string userName_; + + }; + } + } +} +#endif // !ALIBABACLOUD_EHPC_MODEL_BINDACCOUNTTOCLUSTERUSERREQUEST_H_ \ No newline at end of file diff --git a/ehpc/include/alibabacloud/ehpc/model/BindAccountToClusterUserResult.h b/ehpc/include/alibabacloud/ehpc/model/BindAccountToClusterUserResult.h new file mode 100644 index 000000000..ab62ff01e --- /dev/null +++ b/ehpc/include/alibabacloud/ehpc/model/BindAccountToClusterUserResult.h @@ -0,0 +1,49 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed 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. + */ + +#ifndef ALIBABACLOUD_EHPC_MODEL_BINDACCOUNTTOCLUSTERUSERRESULT_H_ +#define ALIBABACLOUD_EHPC_MODEL_BINDACCOUNTTOCLUSTERUSERRESULT_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace EHPC + { + namespace Model + { + class ALIBABACLOUD_EHPC_EXPORT BindAccountToClusterUserResult : public ServiceResult + { + public: + + + BindAccountToClusterUserResult(); + explicit BindAccountToClusterUserResult(const std::string &payload); + ~BindAccountToClusterUserResult(); + + protected: + void parse(const std::string &payload); + private: + + }; + } + } +} +#endif // !ALIBABACLOUD_EHPC_MODEL_BINDACCOUNTTOCLUSTERUSERRESULT_H_ \ No newline at end of file diff --git a/ehpc/include/alibabacloud/ehpc/model/CreateClusterRequest.h b/ehpc/include/alibabacloud/ehpc/model/CreateClusterRequest.h index 14c6c51e8..62973e6b6 100644 --- a/ehpc/include/alibabacloud/ehpc/model/CreateClusterRequest.h +++ b/ehpc/include/alibabacloud/ehpc/model/CreateClusterRequest.h @@ -40,7 +40,7 @@ namespace AlibabaCloud { std::string name; }; - Roles roles; + std::vector roles; std::string volumeId; std::string volumeMountpoint; std::string location; @@ -132,6 +132,8 @@ namespace AlibabaCloud void setVolumeType(const std::string& volumeType); std::string getSystemDiskType()const; void setSystemDiskType(const std::string& systemDiskType); + bool getIsComputeOnecs()const; + void setIsComputeOnecs(bool isComputeOnecs); std::string getVolumeProtocol()const; void setVolumeProtocol(const std::string& volumeProtocol); std::string getClientVersion()const; @@ -192,6 +194,7 @@ namespace AlibabaCloud std::string accessKeyId_; std::string volumeType_; std::string systemDiskType_; + bool isComputeOnecs_; std::string volumeProtocol_; std::string clientVersion_; std::string osTag_; diff --git a/ehpc/include/alibabacloud/ehpc/model/GetAccountingReportRequest.h b/ehpc/include/alibabacloud/ehpc/model/GetAccountingReportRequest.h index 2231a80bd..624e92d2a 100644 --- a/ehpc/include/alibabacloud/ehpc/model/GetAccountingReportRequest.h +++ b/ehpc/include/alibabacloud/ehpc/model/GetAccountingReportRequest.h @@ -39,6 +39,8 @@ namespace AlibabaCloud void setReportType(const std::string& reportType); int getEndTime()const; void setEndTime(int endTime); + std::string getFilterValue()const; + void setFilterValue(const std::string& filterValue); std::string getClusterId()const; void setClusterId(const std::string& clusterId); int getStartTime()const; @@ -49,6 +51,7 @@ namespace AlibabaCloud private: std::string reportType_; int endTime_; + std::string filterValue_; std::string clusterId_; int startTime_; std::string accessKeyId_; diff --git a/ehpc/include/alibabacloud/ehpc/model/GetAccountingReportResult.h b/ehpc/include/alibabacloud/ehpc/model/GetAccountingReportResult.h index 6b7bfb5a5..612a8ec02 100644 --- a/ehpc/include/alibabacloud/ehpc/model/GetAccountingReportResult.h +++ b/ehpc/include/alibabacloud/ehpc/model/GetAccountingReportResult.h @@ -38,13 +38,13 @@ namespace AlibabaCloud explicit GetAccountingReportResult(const std::string &payload); ~GetAccountingReportResult(); std::string getMetrics()const; - std::string getData()const; + std::vector getData()const; protected: void parse(const std::string &payload); private: std::string metrics_; - std::string data_; + std::vector data_; }; } diff --git a/ehpc/include/alibabacloud/ehpc/model/GetAutoScaleConfigResult.h b/ehpc/include/alibabacloud/ehpc/model/GetAutoScaleConfigResult.h index 70105331f..fdcc9bf11 100644 --- a/ehpc/include/alibabacloud/ehpc/model/GetAutoScaleConfigResult.h +++ b/ehpc/include/alibabacloud/ehpc/model/GetAutoScaleConfigResult.h @@ -39,6 +39,7 @@ namespace AlibabaCloud std::string zoneId; std::string vSwitchId; float spotPriceLimit; + std::string hostNamePrefix; std::string instanceType; std::string spotStrategy; }; diff --git a/ehpc/include/alibabacloud/ehpc/model/GetInstanceReportRequest.h b/ehpc/include/alibabacloud/ehpc/model/GetInstanceReportRequest.h new file mode 100644 index 000000000..7dfc40989 --- /dev/null +++ b/ehpc/include/alibabacloud/ehpc/model/GetInstanceReportRequest.h @@ -0,0 +1,60 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed 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. + */ + +#ifndef ALIBABACLOUD_EHPC_MODEL_GETINSTANCEREPORTREQUEST_H_ +#define ALIBABACLOUD_EHPC_MODEL_GETINSTANCEREPORTREQUEST_H_ + +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace EHPC + { + namespace Model + { + class ALIBABACLOUD_EHPC_EXPORT GetInstanceReportRequest : public RpcServiceRequest + { + + public: + GetInstanceReportRequest(); + ~GetInstanceReportRequest(); + + int getEndTime()const; + void setEndTime(int endTime); + std::string getFilterValue()const; + void setFilterValue(const std::string& filterValue); + std::string getClusterId()const; + void setClusterId(const std::string& clusterId); + int getStartTime()const; + void setStartTime(int startTime); + std::string getAccessKeyId()const; + void setAccessKeyId(const std::string& accessKeyId); + + private: + int endTime_; + std::string filterValue_; + std::string clusterId_; + int startTime_; + std::string accessKeyId_; + + }; + } + } +} +#endif // !ALIBABACLOUD_EHPC_MODEL_GETINSTANCEREPORTREQUEST_H_ \ No newline at end of file diff --git a/ehpc/include/alibabacloud/ehpc/model/GetInstanceReportResult.h b/ehpc/include/alibabacloud/ehpc/model/GetInstanceReportResult.h new file mode 100644 index 000000000..7696559a1 --- /dev/null +++ b/ehpc/include/alibabacloud/ehpc/model/GetInstanceReportResult.h @@ -0,0 +1,53 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed 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. + */ + +#ifndef ALIBABACLOUD_EHPC_MODEL_GETINSTANCEREPORTRESULT_H_ +#define ALIBABACLOUD_EHPC_MODEL_GETINSTANCEREPORTRESULT_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace EHPC + { + namespace Model + { + class ALIBABACLOUD_EHPC_EXPORT GetInstanceReportResult : public ServiceResult + { + public: + + + GetInstanceReportResult(); + explicit GetInstanceReportResult(const std::string &payload); + ~GetInstanceReportResult(); + std::string getMetrics()const; + std::vector getData()const; + + protected: + void parse(const std::string &payload); + private: + std::string metrics_; + std::vector data_; + + }; + } + } +} +#endif // !ALIBABACLOUD_EHPC_MODEL_GETINSTANCEREPORTRESULT_H_ \ No newline at end of file diff --git a/ehpc/include/alibabacloud/ehpc/model/GetJobReportRequest.h b/ehpc/include/alibabacloud/ehpc/model/GetJobReportRequest.h new file mode 100644 index 000000000..173b20bfe --- /dev/null +++ b/ehpc/include/alibabacloud/ehpc/model/GetJobReportRequest.h @@ -0,0 +1,63 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed 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. + */ + +#ifndef ALIBABACLOUD_EHPC_MODEL_GETJOBREPORTREQUEST_H_ +#define ALIBABACLOUD_EHPC_MODEL_GETJOBREPORTREQUEST_H_ + +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace EHPC + { + namespace Model + { + class ALIBABACLOUD_EHPC_EXPORT GetJobReportRequest : public RpcServiceRequest + { + + public: + GetJobReportRequest(); + ~GetJobReportRequest(); + + std::string getReportType()const; + void setReportType(const std::string& reportType); + int getEndTime()const; + void setEndTime(int endTime); + std::string getFilterValue()const; + void setFilterValue(const std::string& filterValue); + std::string getClusterId()const; + void setClusterId(const std::string& clusterId); + int getStartTime()const; + void setStartTime(int startTime); + std::string getAccessKeyId()const; + void setAccessKeyId(const std::string& accessKeyId); + + private: + std::string reportType_; + int endTime_; + std::string filterValue_; + std::string clusterId_; + int startTime_; + std::string accessKeyId_; + + }; + } + } +} +#endif // !ALIBABACLOUD_EHPC_MODEL_GETJOBREPORTREQUEST_H_ \ No newline at end of file diff --git a/ehpc/include/alibabacloud/ehpc/model/GetJobReportResult.h b/ehpc/include/alibabacloud/ehpc/model/GetJobReportResult.h new file mode 100644 index 000000000..d02a87cc4 --- /dev/null +++ b/ehpc/include/alibabacloud/ehpc/model/GetJobReportResult.h @@ -0,0 +1,53 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed 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. + */ + +#ifndef ALIBABACLOUD_EHPC_MODEL_GETJOBREPORTRESULT_H_ +#define ALIBABACLOUD_EHPC_MODEL_GETJOBREPORTRESULT_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace EHPC + { + namespace Model + { + class ALIBABACLOUD_EHPC_EXPORT GetJobReportResult : public ServiceResult + { + public: + + + GetJobReportResult(); + explicit GetJobReportResult(const std::string &payload); + ~GetJobReportResult(); + std::string getMetrics()const; + std::vector getData()const; + + protected: + void parse(const std::string &payload); + private: + std::string metrics_; + std::vector data_; + + }; + } + } +} +#endif // !ALIBABACLOUD_EHPC_MODEL_GETJOBREPORTRESULT_H_ \ No newline at end of file diff --git a/ehpc/include/alibabacloud/ehpc/model/GetTotalQueueReportRequest.h b/ehpc/include/alibabacloud/ehpc/model/GetTotalQueueReportRequest.h new file mode 100644 index 000000000..bd8cf437f --- /dev/null +++ b/ehpc/include/alibabacloud/ehpc/model/GetTotalQueueReportRequest.h @@ -0,0 +1,57 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed 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. + */ + +#ifndef ALIBABACLOUD_EHPC_MODEL_GETTOTALQUEUEREPORTREQUEST_H_ +#define ALIBABACLOUD_EHPC_MODEL_GETTOTALQUEUEREPORTREQUEST_H_ + +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace EHPC + { + namespace Model + { + class ALIBABACLOUD_EHPC_EXPORT GetTotalQueueReportRequest : public RpcServiceRequest + { + + public: + GetTotalQueueReportRequest(); + ~GetTotalQueueReportRequest(); + + int getEndTime()const; + void setEndTime(int endTime); + std::string getClusterId()const; + void setClusterId(const std::string& clusterId); + int getStartTime()const; + void setStartTime(int startTime); + std::string getAccessKeyId()const; + void setAccessKeyId(const std::string& accessKeyId); + + private: + int endTime_; + std::string clusterId_; + int startTime_; + std::string accessKeyId_; + + }; + } + } +} +#endif // !ALIBABACLOUD_EHPC_MODEL_GETTOTALQUEUEREPORTREQUEST_H_ \ No newline at end of file diff --git a/ehpc/include/alibabacloud/ehpc/model/GetTotalQueueReportResult.h b/ehpc/include/alibabacloud/ehpc/model/GetTotalQueueReportResult.h new file mode 100644 index 000000000..d027800f2 --- /dev/null +++ b/ehpc/include/alibabacloud/ehpc/model/GetTotalQueueReportResult.h @@ -0,0 +1,53 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed 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. + */ + +#ifndef ALIBABACLOUD_EHPC_MODEL_GETTOTALQUEUEREPORTRESULT_H_ +#define ALIBABACLOUD_EHPC_MODEL_GETTOTALQUEUEREPORTRESULT_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace EHPC + { + namespace Model + { + class ALIBABACLOUD_EHPC_EXPORT GetTotalQueueReportResult : public ServiceResult + { + public: + + + GetTotalQueueReportResult(); + explicit GetTotalQueueReportResult(const std::string &payload); + ~GetTotalQueueReportResult(); + std::string getMetrics()const; + std::vector getData()const; + + protected: + void parse(const std::string &payload); + private: + std::string metrics_; + std::vector data_; + + }; + } + } +} +#endif // !ALIBABACLOUD_EHPC_MODEL_GETTOTALQUEUEREPORTRESULT_H_ \ No newline at end of file diff --git a/ehpc/include/alibabacloud/ehpc/model/GetTotalUserReportRequest.h b/ehpc/include/alibabacloud/ehpc/model/GetTotalUserReportRequest.h new file mode 100644 index 000000000..7ed6a3a5b --- /dev/null +++ b/ehpc/include/alibabacloud/ehpc/model/GetTotalUserReportRequest.h @@ -0,0 +1,57 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed 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. + */ + +#ifndef ALIBABACLOUD_EHPC_MODEL_GETTOTALUSERREPORTREQUEST_H_ +#define ALIBABACLOUD_EHPC_MODEL_GETTOTALUSERREPORTREQUEST_H_ + +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace EHPC + { + namespace Model + { + class ALIBABACLOUD_EHPC_EXPORT GetTotalUserReportRequest : public RpcServiceRequest + { + + public: + GetTotalUserReportRequest(); + ~GetTotalUserReportRequest(); + + int getEndTime()const; + void setEndTime(int endTime); + std::string getClusterId()const; + void setClusterId(const std::string& clusterId); + int getStartTime()const; + void setStartTime(int startTime); + std::string getAccessKeyId()const; + void setAccessKeyId(const std::string& accessKeyId); + + private: + int endTime_; + std::string clusterId_; + int startTime_; + std::string accessKeyId_; + + }; + } + } +} +#endif // !ALIBABACLOUD_EHPC_MODEL_GETTOTALUSERREPORTREQUEST_H_ \ No newline at end of file diff --git a/ehpc/include/alibabacloud/ehpc/model/GetTotalUserReportResult.h b/ehpc/include/alibabacloud/ehpc/model/GetTotalUserReportResult.h new file mode 100644 index 000000000..b37c3af68 --- /dev/null +++ b/ehpc/include/alibabacloud/ehpc/model/GetTotalUserReportResult.h @@ -0,0 +1,53 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed 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. + */ + +#ifndef ALIBABACLOUD_EHPC_MODEL_GETTOTALUSERREPORTRESULT_H_ +#define ALIBABACLOUD_EHPC_MODEL_GETTOTALUSERREPORTRESULT_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace EHPC + { + namespace Model + { + class ALIBABACLOUD_EHPC_EXPORT GetTotalUserReportResult : public ServiceResult + { + public: + + + GetTotalUserReportResult(); + explicit GetTotalUserReportResult(const std::string &payload); + ~GetTotalUserReportResult(); + std::string getMetrics()const; + std::vector getData()const; + + protected: + void parse(const std::string &payload); + private: + std::string metrics_; + std::vector data_; + + }; + } + } +} +#endif // !ALIBABACLOUD_EHPC_MODEL_GETTOTALUSERREPORTRESULT_H_ \ No newline at end of file diff --git a/ehpc/include/alibabacloud/ehpc/model/GetWorkbenchTokenRequest.h b/ehpc/include/alibabacloud/ehpc/model/GetWorkbenchTokenRequest.h new file mode 100644 index 000000000..fa0cef6fe --- /dev/null +++ b/ehpc/include/alibabacloud/ehpc/model/GetWorkbenchTokenRequest.h @@ -0,0 +1,69 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed 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. + */ + +#ifndef ALIBABACLOUD_EHPC_MODEL_GETWORKBENCHTOKENREQUEST_H_ +#define ALIBABACLOUD_EHPC_MODEL_GETWORKBENCHTOKENREQUEST_H_ + +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace EHPC + { + namespace Model + { + class ALIBABACLOUD_EHPC_EXPORT GetWorkbenchTokenRequest : public RpcServiceRequest + { + + public: + GetWorkbenchTokenRequest(); + ~GetWorkbenchTokenRequest(); + + std::string getClusterId()const; + void setClusterId(const std::string& clusterId); + std::string getAccessKeyId()const; + void setAccessKeyId(const std::string& accessKeyId); + std::string getUserPassword()const; + void setUserPassword(const std::string& userPassword); + std::string getInstanceId()const; + void setInstanceId(const std::string& instanceId); + int getPort()const; + void setPort(int port); + std::string getAccountSessionTicket()const; + void setAccountSessionTicket(const std::string& accountSessionTicket); + std::string getAccountUid()const; + void setAccountUid(const std::string& accountUid); + std::string getUserName()const; + void setUserName(const std::string& userName); + + private: + std::string clusterId_; + std::string accessKeyId_; + std::string userPassword_; + std::string instanceId_; + int port_; + std::string accountSessionTicket_; + std::string accountUid_; + std::string userName_; + + }; + } + } +} +#endif // !ALIBABACLOUD_EHPC_MODEL_GETWORKBENCHTOKENREQUEST_H_ \ No newline at end of file diff --git a/ehpc/include/alibabacloud/ehpc/model/GetWorkbenchTokenResult.h b/ehpc/include/alibabacloud/ehpc/model/GetWorkbenchTokenResult.h new file mode 100644 index 000000000..7aeba21f3 --- /dev/null +++ b/ehpc/include/alibabacloud/ehpc/model/GetWorkbenchTokenResult.h @@ -0,0 +1,64 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed 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. + */ + +#ifndef ALIBABACLOUD_EHPC_MODEL_GETWORKBENCHTOKENRESULT_H_ +#define ALIBABACLOUD_EHPC_MODEL_GETWORKBENCHTOKENRESULT_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace EHPC + { + namespace Model + { + class ALIBABACLOUD_EHPC_EXPORT GetWorkbenchTokenResult : public ServiceResult + { + public: + struct Root + { + struct InstanceLoginView + { + std::string baseViewUrl; + std::string fileTreeViewUrl; + std::string defaultViewUrl; + std::string rdpViewUrl; + std::string viewName; + std::string terminalViewUrl; + }; + InstanceLoginView instanceLoginView; + }; + + + GetWorkbenchTokenResult(); + explicit GetWorkbenchTokenResult(const std::string &payload); + ~GetWorkbenchTokenResult(); + Root getRoot()const; + + protected: + void parse(const std::string &payload); + private: + Root root_; + + }; + } + } +} +#endif // !ALIBABACLOUD_EHPC_MODEL_GETWORKBENCHTOKENRESULT_H_ \ No newline at end of file diff --git a/ehpc/include/alibabacloud/ehpc/model/ListAccountMappingRequest.h b/ehpc/include/alibabacloud/ehpc/model/ListAccountMappingRequest.h new file mode 100644 index 000000000..ccfe355fa --- /dev/null +++ b/ehpc/include/alibabacloud/ehpc/model/ListAccountMappingRequest.h @@ -0,0 +1,51 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed 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. + */ + +#ifndef ALIBABACLOUD_EHPC_MODEL_LISTACCOUNTMAPPINGREQUEST_H_ +#define ALIBABACLOUD_EHPC_MODEL_LISTACCOUNTMAPPINGREQUEST_H_ + +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace EHPC + { + namespace Model + { + class ALIBABACLOUD_EHPC_EXPORT ListAccountMappingRequest : public RpcServiceRequest + { + + public: + ListAccountMappingRequest(); + ~ListAccountMappingRequest(); + + std::string getClusterId()const; + void setClusterId(const std::string& clusterId); + std::string getAccessKeyId()const; + void setAccessKeyId(const std::string& accessKeyId); + + private: + std::string clusterId_; + std::string accessKeyId_; + + }; + } + } +} +#endif // !ALIBABACLOUD_EHPC_MODEL_LISTACCOUNTMAPPINGREQUEST_H_ \ No newline at end of file diff --git a/ehpc/include/alibabacloud/ehpc/model/ListAccountMappingResult.h b/ehpc/include/alibabacloud/ehpc/model/ListAccountMappingResult.h new file mode 100644 index 000000000..dc942ce81 --- /dev/null +++ b/ehpc/include/alibabacloud/ehpc/model/ListAccountMappingResult.h @@ -0,0 +1,57 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed 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. + */ + +#ifndef ALIBABACLOUD_EHPC_MODEL_LISTACCOUNTMAPPINGRESULT_H_ +#define ALIBABACLOUD_EHPC_MODEL_LISTACCOUNTMAPPINGRESULT_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace EHPC + { + namespace Model + { + class ALIBABACLOUD_EHPC_EXPORT ListAccountMappingResult : public ServiceResult + { + public: + struct UserMapping + { + std::string userName; + std::string accountId; + std::string accountName; + }; + + + ListAccountMappingResult(); + explicit ListAccountMappingResult(const std::string &payload); + ~ListAccountMappingResult(); + std::vector getUserMappings()const; + + protected: + void parse(const std::string &payload); + private: + std::vector userMappings_; + + }; + } + } +} +#endif // !ALIBABACLOUD_EHPC_MODEL_LISTACCOUNTMAPPINGRESULT_H_ \ No newline at end of file diff --git a/ehpc/include/alibabacloud/ehpc/model/ListFileSystemWithMountTargetsResult.h b/ehpc/include/alibabacloud/ehpc/model/ListFileSystemWithMountTargetsResult.h index 6c8edff49..6ac85facc 100644 --- a/ehpc/include/alibabacloud/ehpc/model/ListFileSystemWithMountTargetsResult.h +++ b/ehpc/include/alibabacloud/ehpc/model/ListFileSystemWithMountTargetsResult.h @@ -47,15 +47,20 @@ namespace AlibabaCloud std::string networkType; std::string accessGroup; }; + std::string status; std::string storageType; + std::string createTime; + int meteredSize; + int bandWidth; + int encryptType; + int capacity; std::string protocolType; std::vector packageList; - std::string createTime; + std::string fileSystemType; std::vector mountTargetList; std::string destription; std::string fileSystemId; std::string regionId; - std::string meteredSize; }; diff --git a/ehpc/include/alibabacloud/ehpc/model/MountNFSRequest.h b/ehpc/include/alibabacloud/ehpc/model/MountNFSRequest.h index 595b8790e..993acac70 100644 --- a/ehpc/include/alibabacloud/ehpc/model/MountNFSRequest.h +++ b/ehpc/include/alibabacloud/ehpc/model/MountNFSRequest.h @@ -43,12 +43,15 @@ namespace AlibabaCloud void setInstanceId(const std::string& instanceId); std::string getNfsDir()const; void setNfsDir(const std::string& nfsDir); + std::string getProtocolType()const; + void setProtocolType(const std::string& protocolType); private: std::string mountDir_; std::string accessKeyId_; std::string instanceId_; std::string nfsDir_; + std::string protocolType_; }; } diff --git a/ehpc/include/alibabacloud/ehpc/model/SetAutoScaleConfigRequest.h b/ehpc/include/alibabacloud/ehpc/model/SetAutoScaleConfigRequest.h index e24e983ad..296b08935 100644 --- a/ehpc/include/alibabacloud/ehpc/model/SetAutoScaleConfigRequest.h +++ b/ehpc/include/alibabacloud/ehpc/model/SetAutoScaleConfigRequest.h @@ -40,9 +40,10 @@ namespace AlibabaCloud std::string vSwitchId; std::string instanceType; std::string zoneId; + std::string hostNamePrefix; float spotPriceLimit; }; - InstanceTypes instanceTypes; + std::vector instanceTypes; std::string instanceType; bool enableAutoGrow; float spotPriceLimit; diff --git a/ehpc/include/alibabacloud/ehpc/model/UnbindAccountToClusterUserRequest.h b/ehpc/include/alibabacloud/ehpc/model/UnbindAccountToClusterUserRequest.h new file mode 100644 index 000000000..440f71e54 --- /dev/null +++ b/ehpc/include/alibabacloud/ehpc/model/UnbindAccountToClusterUserRequest.h @@ -0,0 +1,57 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed 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. + */ + +#ifndef ALIBABACLOUD_EHPC_MODEL_UNBINDACCOUNTTOCLUSTERUSERREQUEST_H_ +#define ALIBABACLOUD_EHPC_MODEL_UNBINDACCOUNTTOCLUSTERUSERREQUEST_H_ + +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace EHPC + { + namespace Model + { + class ALIBABACLOUD_EHPC_EXPORT UnbindAccountToClusterUserRequest : public RpcServiceRequest + { + + public: + UnbindAccountToClusterUserRequest(); + ~UnbindAccountToClusterUserRequest(); + + std::string getClusterId()const; + void setClusterId(const std::string& clusterId); + std::string getAccessKeyId()const; + void setAccessKeyId(const std::string& accessKeyId); + std::string getAccountUid()const; + void setAccountUid(const std::string& accountUid); + std::string getUserName()const; + void setUserName(const std::string& userName); + + private: + std::string clusterId_; + std::string accessKeyId_; + std::string accountUid_; + std::string userName_; + + }; + } + } +} +#endif // !ALIBABACLOUD_EHPC_MODEL_UNBINDACCOUNTTOCLUSTERUSERREQUEST_H_ \ No newline at end of file diff --git a/ehpc/include/alibabacloud/ehpc/model/UnbindAccountToClusterUserResult.h b/ehpc/include/alibabacloud/ehpc/model/UnbindAccountToClusterUserResult.h new file mode 100644 index 000000000..f3e1b5fb8 --- /dev/null +++ b/ehpc/include/alibabacloud/ehpc/model/UnbindAccountToClusterUserResult.h @@ -0,0 +1,49 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed 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. + */ + +#ifndef ALIBABACLOUD_EHPC_MODEL_UNBINDACCOUNTTOCLUSTERUSERRESULT_H_ +#define ALIBABACLOUD_EHPC_MODEL_UNBINDACCOUNTTOCLUSTERUSERRESULT_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace EHPC + { + namespace Model + { + class ALIBABACLOUD_EHPC_EXPORT UnbindAccountToClusterUserResult : public ServiceResult + { + public: + + + UnbindAccountToClusterUserResult(); + explicit UnbindAccountToClusterUserResult(const std::string &payload); + ~UnbindAccountToClusterUserResult(); + + protected: + void parse(const std::string &payload); + private: + + }; + } + } +} +#endif // !ALIBABACLOUD_EHPC_MODEL_UNBINDACCOUNTTOCLUSTERUSERRESULT_H_ \ No newline at end of file diff --git a/ehpc/include/alibabacloud/ehpc/model/UpdateClusterVolumesRequest.h b/ehpc/include/alibabacloud/ehpc/model/UpdateClusterVolumesRequest.h index d921d4735..12ab8c602 100644 --- a/ehpc/include/alibabacloud/ehpc/model/UpdateClusterVolumesRequest.h +++ b/ehpc/include/alibabacloud/ehpc/model/UpdateClusterVolumesRequest.h @@ -40,7 +40,7 @@ namespace AlibabaCloud { std::string name; }; - Roles roles; + std::vector roles; std::string volumeId; std::string volumeMountpoint; std::string location; diff --git a/ehpc/src/EHPCClient.cc b/ehpc/src/EHPCClient.cc index e08e034f5..744c2d715 100644 --- a/ehpc/src/EHPCClient.cc +++ b/ehpc/src/EHPCClient.cc @@ -31,21 +31,21 @@ EHPCClient::EHPCClient(const Credentials &credentials, const ClientConfiguration RpcServiceClient(SERVICE_NAME, std::make_shared(credentials), configuration) { auto locationClient = std::make_shared(credentials, configuration); - endpointProvider_ = std::make_shared(locationClient, configuration.regionId(), SERVICE_NAME, "ehpc"); + endpointProvider_ = std::make_shared(locationClient, configuration.regionId(), SERVICE_NAME, "ehs"); } EHPCClient::EHPCClient(const std::shared_ptr& credentialsProvider, const ClientConfiguration & configuration) : RpcServiceClient(SERVICE_NAME, credentialsProvider, configuration) { auto locationClient = std::make_shared(credentialsProvider, configuration); - endpointProvider_ = std::make_shared(locationClient, configuration.regionId(), SERVICE_NAME, "ehpc"); + endpointProvider_ = std::make_shared(locationClient, configuration.regionId(), SERVICE_NAME, "ehs"); } EHPCClient::EHPCClient(const std::string & accessKeyId, const std::string & accessKeySecret, const ClientConfiguration & configuration) : RpcServiceClient(SERVICE_NAME, std::make_shared(accessKeyId, accessKeySecret), configuration) { auto locationClient = std::make_shared(accessKeyId, accessKeySecret, configuration); - endpointProvider_ = std::make_shared(locationClient, configuration.regionId(), SERVICE_NAME, "ehpc"); + endpointProvider_ = std::make_shared(locationClient, configuration.regionId(), SERVICE_NAME, "ehs"); } EHPCClient::~EHPCClient() @@ -231,6 +231,42 @@ EHPCClient::AddUsersOutcomeCallable EHPCClient::addUsersCallable(const AddUsersR return task->get_future(); } +EHPCClient::BindAccountToClusterUserOutcome EHPCClient::bindAccountToClusterUser(const BindAccountToClusterUserRequest &request) const +{ + auto endpointOutcome = endpointProvider_->getEndpoint(); + if (!endpointOutcome.isSuccess()) + return BindAccountToClusterUserOutcome(endpointOutcome.error()); + + auto outcome = makeRequest(endpointOutcome.result(), request); + + if (outcome.isSuccess()) + return BindAccountToClusterUserOutcome(BindAccountToClusterUserResult(outcome.result())); + else + return BindAccountToClusterUserOutcome(outcome.error()); +} + +void EHPCClient::bindAccountToClusterUserAsync(const BindAccountToClusterUserRequest& request, const BindAccountToClusterUserAsyncHandler& handler, const std::shared_ptr& context) const +{ + auto fn = [this, request, handler, context]() + { + handler(this, request, bindAccountToClusterUser(request), context); + }; + + asyncExecute(new Runnable(fn)); +} + +EHPCClient::BindAccountToClusterUserOutcomeCallable EHPCClient::bindAccountToClusterUserCallable(const BindAccountToClusterUserRequest &request) const +{ + auto task = std::make_shared>( + [this, request]() + { + return this->bindAccountToClusterUser(request); + }); + + asyncExecute(new Runnable([task]() { (*task)(); })); + return task->get_future(); +} + EHPCClient::CreateClusterOutcome EHPCClient::createCluster(const CreateClusterRequest &request) const { auto endpointOutcome = endpointProvider_->getEndpoint(); @@ -1563,6 +1599,150 @@ EHPCClient::GetHybridClusterConfigOutcomeCallable EHPCClient::getHybridClusterCo return task->get_future(); } +EHPCClient::GetInstanceReportOutcome EHPCClient::getInstanceReport(const GetInstanceReportRequest &request) const +{ + auto endpointOutcome = endpointProvider_->getEndpoint(); + if (!endpointOutcome.isSuccess()) + return GetInstanceReportOutcome(endpointOutcome.error()); + + auto outcome = makeRequest(endpointOutcome.result(), request); + + if (outcome.isSuccess()) + return GetInstanceReportOutcome(GetInstanceReportResult(outcome.result())); + else + return GetInstanceReportOutcome(outcome.error()); +} + +void EHPCClient::getInstanceReportAsync(const GetInstanceReportRequest& request, const GetInstanceReportAsyncHandler& handler, const std::shared_ptr& context) const +{ + auto fn = [this, request, handler, context]() + { + handler(this, request, getInstanceReport(request), context); + }; + + asyncExecute(new Runnable(fn)); +} + +EHPCClient::GetInstanceReportOutcomeCallable EHPCClient::getInstanceReportCallable(const GetInstanceReportRequest &request) const +{ + auto task = std::make_shared>( + [this, request]() + { + return this->getInstanceReport(request); + }); + + asyncExecute(new Runnable([task]() { (*task)(); })); + return task->get_future(); +} + +EHPCClient::GetJobReportOutcome EHPCClient::getJobReport(const GetJobReportRequest &request) const +{ + auto endpointOutcome = endpointProvider_->getEndpoint(); + if (!endpointOutcome.isSuccess()) + return GetJobReportOutcome(endpointOutcome.error()); + + auto outcome = makeRequest(endpointOutcome.result(), request); + + if (outcome.isSuccess()) + return GetJobReportOutcome(GetJobReportResult(outcome.result())); + else + return GetJobReportOutcome(outcome.error()); +} + +void EHPCClient::getJobReportAsync(const GetJobReportRequest& request, const GetJobReportAsyncHandler& handler, const std::shared_ptr& context) const +{ + auto fn = [this, request, handler, context]() + { + handler(this, request, getJobReport(request), context); + }; + + asyncExecute(new Runnable(fn)); +} + +EHPCClient::GetJobReportOutcomeCallable EHPCClient::getJobReportCallable(const GetJobReportRequest &request) const +{ + auto task = std::make_shared>( + [this, request]() + { + return this->getJobReport(request); + }); + + asyncExecute(new Runnable([task]() { (*task)(); })); + return task->get_future(); +} + +EHPCClient::GetTotalQueueReportOutcome EHPCClient::getTotalQueueReport(const GetTotalQueueReportRequest &request) const +{ + auto endpointOutcome = endpointProvider_->getEndpoint(); + if (!endpointOutcome.isSuccess()) + return GetTotalQueueReportOutcome(endpointOutcome.error()); + + auto outcome = makeRequest(endpointOutcome.result(), request); + + if (outcome.isSuccess()) + return GetTotalQueueReportOutcome(GetTotalQueueReportResult(outcome.result())); + else + return GetTotalQueueReportOutcome(outcome.error()); +} + +void EHPCClient::getTotalQueueReportAsync(const GetTotalQueueReportRequest& request, const GetTotalQueueReportAsyncHandler& handler, const std::shared_ptr& context) const +{ + auto fn = [this, request, handler, context]() + { + handler(this, request, getTotalQueueReport(request), context); + }; + + asyncExecute(new Runnable(fn)); +} + +EHPCClient::GetTotalQueueReportOutcomeCallable EHPCClient::getTotalQueueReportCallable(const GetTotalQueueReportRequest &request) const +{ + auto task = std::make_shared>( + [this, request]() + { + return this->getTotalQueueReport(request); + }); + + asyncExecute(new Runnable([task]() { (*task)(); })); + return task->get_future(); +} + +EHPCClient::GetTotalUserReportOutcome EHPCClient::getTotalUserReport(const GetTotalUserReportRequest &request) const +{ + auto endpointOutcome = endpointProvider_->getEndpoint(); + if (!endpointOutcome.isSuccess()) + return GetTotalUserReportOutcome(endpointOutcome.error()); + + auto outcome = makeRequest(endpointOutcome.result(), request); + + if (outcome.isSuccess()) + return GetTotalUserReportOutcome(GetTotalUserReportResult(outcome.result())); + else + return GetTotalUserReportOutcome(outcome.error()); +} + +void EHPCClient::getTotalUserReportAsync(const GetTotalUserReportRequest& request, const GetTotalUserReportAsyncHandler& handler, const std::shared_ptr& context) const +{ + auto fn = [this, request, handler, context]() + { + handler(this, request, getTotalUserReport(request), context); + }; + + asyncExecute(new Runnable(fn)); +} + +EHPCClient::GetTotalUserReportOutcomeCallable EHPCClient::getTotalUserReportCallable(const GetTotalUserReportRequest &request) const +{ + auto task = std::make_shared>( + [this, request]() + { + return this->getTotalUserReport(request); + }); + + asyncExecute(new Runnable([task]() { (*task)(); })); + return task->get_future(); +} + EHPCClient::GetVisualServiceStatusOutcome EHPCClient::getVisualServiceStatus(const GetVisualServiceStatusRequest &request) const { auto endpointOutcome = endpointProvider_->getEndpoint(); @@ -1599,6 +1779,42 @@ EHPCClient::GetVisualServiceStatusOutcomeCallable EHPCClient::getVisualServiceSt return task->get_future(); } +EHPCClient::GetWorkbenchTokenOutcome EHPCClient::getWorkbenchToken(const GetWorkbenchTokenRequest &request) const +{ + auto endpointOutcome = endpointProvider_->getEndpoint(); + if (!endpointOutcome.isSuccess()) + return GetWorkbenchTokenOutcome(endpointOutcome.error()); + + auto outcome = makeRequest(endpointOutcome.result(), request); + + if (outcome.isSuccess()) + return GetWorkbenchTokenOutcome(GetWorkbenchTokenResult(outcome.result())); + else + return GetWorkbenchTokenOutcome(outcome.error()); +} + +void EHPCClient::getWorkbenchTokenAsync(const GetWorkbenchTokenRequest& request, const GetWorkbenchTokenAsyncHandler& handler, const std::shared_ptr& context) const +{ + auto fn = [this, request, handler, context]() + { + handler(this, request, getWorkbenchToken(request), context); + }; + + asyncExecute(new Runnable(fn)); +} + +EHPCClient::GetWorkbenchTokenOutcomeCallable EHPCClient::getWorkbenchTokenCallable(const GetWorkbenchTokenRequest &request) const +{ + auto task = std::make_shared>( + [this, request]() + { + return this->getWorkbenchToken(request); + }); + + asyncExecute(new Runnable([task]() { (*task)(); })); + return task->get_future(); +} + EHPCClient::InstallNFSClientOutcome EHPCClient::installNFSClient(const InstallNFSClientRequest &request) const { auto endpointOutcome = endpointProvider_->getEndpoint(); @@ -1707,6 +1923,42 @@ EHPCClient::InvokeShellCommandOutcomeCallable EHPCClient::invokeShellCommandCall return task->get_future(); } +EHPCClient::ListAccountMappingOutcome EHPCClient::listAccountMapping(const ListAccountMappingRequest &request) const +{ + auto endpointOutcome = endpointProvider_->getEndpoint(); + if (!endpointOutcome.isSuccess()) + return ListAccountMappingOutcome(endpointOutcome.error()); + + auto outcome = makeRequest(endpointOutcome.result(), request); + + if (outcome.isSuccess()) + return ListAccountMappingOutcome(ListAccountMappingResult(outcome.result())); + else + return ListAccountMappingOutcome(outcome.error()); +} + +void EHPCClient::listAccountMappingAsync(const ListAccountMappingRequest& request, const ListAccountMappingAsyncHandler& handler, const std::shared_ptr& context) const +{ + auto fn = [this, request, handler, context]() + { + handler(this, request, listAccountMapping(request), context); + }; + + asyncExecute(new Runnable(fn)); +} + +EHPCClient::ListAccountMappingOutcomeCallable EHPCClient::listAccountMappingCallable(const ListAccountMappingRequest &request) const +{ + auto task = std::make_shared>( + [this, request]() + { + return this->listAccountMapping(request); + }); + + asyncExecute(new Runnable([task]() { (*task)(); })); + return task->get_future(); +} + EHPCClient::ListAvailableEcsTypesOutcome EHPCClient::listAvailableEcsTypes(const ListAvailableEcsTypesRequest &request) const { auto endpointOutcome = endpointProvider_->getEndpoint(); @@ -3687,6 +3939,42 @@ EHPCClient::SubmitJobOutcomeCallable EHPCClient::submitJobCallable(const SubmitJ return task->get_future(); } +EHPCClient::UnbindAccountToClusterUserOutcome EHPCClient::unbindAccountToClusterUser(const UnbindAccountToClusterUserRequest &request) const +{ + auto endpointOutcome = endpointProvider_->getEndpoint(); + if (!endpointOutcome.isSuccess()) + return UnbindAccountToClusterUserOutcome(endpointOutcome.error()); + + auto outcome = makeRequest(endpointOutcome.result(), request); + + if (outcome.isSuccess()) + return UnbindAccountToClusterUserOutcome(UnbindAccountToClusterUserResult(outcome.result())); + else + return UnbindAccountToClusterUserOutcome(outcome.error()); +} + +void EHPCClient::unbindAccountToClusterUserAsync(const UnbindAccountToClusterUserRequest& request, const UnbindAccountToClusterUserAsyncHandler& handler, const std::shared_ptr& context) const +{ + auto fn = [this, request, handler, context]() + { + handler(this, request, unbindAccountToClusterUser(request), context); + }; + + asyncExecute(new Runnable(fn)); +} + +EHPCClient::UnbindAccountToClusterUserOutcomeCallable EHPCClient::unbindAccountToClusterUserCallable(const UnbindAccountToClusterUserRequest &request) const +{ + auto task = std::make_shared>( + [this, request]() + { + return this->unbindAccountToClusterUser(request); + }); + + asyncExecute(new Runnable([task]() { (*task)(); })); + return task->get_future(); +} + EHPCClient::UninstallSoftwareOutcome EHPCClient::uninstallSoftware(const UninstallSoftwareRequest &request) const { auto endpointOutcome = endpointProvider_->getEndpoint(); diff --git a/ehpc/src/model/AddContainerAppRequest.cc b/ehpc/src/model/AddContainerAppRequest.cc index ab52e3cd2..f7bbe0445 100644 --- a/ehpc/src/model/AddContainerAppRequest.cc +++ b/ehpc/src/model/AddContainerAppRequest.cc @@ -20,7 +20,9 @@ using AlibabaCloud::EHPC::Model::AddContainerAppRequest; AddContainerAppRequest::AddContainerAppRequest() : RpcServiceRequest("ehpc", "2018-04-12", "AddContainerApp") -{} +{ + setMethod(HttpRequest::Method::Get); +} AddContainerAppRequest::~AddContainerAppRequest() {} diff --git a/ehpc/src/model/AddLocalNodesRequest.cc b/ehpc/src/model/AddLocalNodesRequest.cc index 41dd38a57..c6c33309e 100644 --- a/ehpc/src/model/AddLocalNodesRequest.cc +++ b/ehpc/src/model/AddLocalNodesRequest.cc @@ -20,7 +20,9 @@ using AlibabaCloud::EHPC::Model::AddLocalNodesRequest; AddLocalNodesRequest::AddLocalNodesRequest() : RpcServiceRequest("ehpc", "2018-04-12", "AddLocalNodes") -{} +{ + setMethod(HttpRequest::Method::Get); +} AddLocalNodesRequest::~AddLocalNodesRequest() {} diff --git a/ehpc/src/model/AddNodesRequest.cc b/ehpc/src/model/AddNodesRequest.cc index 373dd5bbd..3c809b875 100644 --- a/ehpc/src/model/AddNodesRequest.cc +++ b/ehpc/src/model/AddNodesRequest.cc @@ -20,7 +20,9 @@ using AlibabaCloud::EHPC::Model::AddNodesRequest; AddNodesRequest::AddNodesRequest() : RpcServiceRequest("ehpc", "2018-04-12", "AddNodes") -{} +{ + setMethod(HttpRequest::Method::Get); +} AddNodesRequest::~AddNodesRequest() {} @@ -102,6 +104,17 @@ void AddNodesRequest::setInstanceType(const std::string& instanceType) setCoreParameter("InstanceType", instanceType); } +std::string AddNodesRequest::getHostNamePrefix()const +{ + return hostNamePrefix_; +} + +void AddNodesRequest::setHostNamePrefix(const std::string& hostNamePrefix) +{ + hostNamePrefix_ = hostNamePrefix; + setCoreParameter("HostNamePrefix", hostNamePrefix); +} + std::string AddNodesRequest::getComputeSpotPriceLimit()const { return computeSpotPriceLimit_; diff --git a/ehpc/src/model/AddQueueRequest.cc b/ehpc/src/model/AddQueueRequest.cc index 9c4e1a4ed..f92e50053 100644 --- a/ehpc/src/model/AddQueueRequest.cc +++ b/ehpc/src/model/AddQueueRequest.cc @@ -20,7 +20,9 @@ using AlibabaCloud::EHPC::Model::AddQueueRequest; AddQueueRequest::AddQueueRequest() : RpcServiceRequest("ehpc", "2018-04-12", "AddQueue") -{} +{ + setMethod(HttpRequest::Method::Get); +} AddQueueRequest::~AddQueueRequest() {} diff --git a/ehpc/src/model/AddUsersRequest.cc b/ehpc/src/model/AddUsersRequest.cc index 6aeba3d85..1fcbe353f 100644 --- a/ehpc/src/model/AddUsersRequest.cc +++ b/ehpc/src/model/AddUsersRequest.cc @@ -20,7 +20,9 @@ using AlibabaCloud::EHPC::Model::AddUsersRequest; AddUsersRequest::AddUsersRequest() : RpcServiceRequest("ehpc", "2018-04-12", "AddUsers") -{} +{ + setMethod(HttpRequest::Method::Get); +} AddUsersRequest::~AddUsersRequest() {} @@ -55,13 +57,12 @@ std::vector AddUsersRequest::getUser()const void AddUsersRequest::setUser(const std::vector& user) { user_ = user; - int i = 0; - for(int i = 0; i!= user.size(); i++) { - auto obj = user.at(i); - std::string str ="User."+ std::to_string(i); - setCoreParameter(str + ".Password", obj.password); - setCoreParameter(str + ".Name", obj.name); - setCoreParameter(str + ".Group", obj.group); + for(int dep1 = 0; dep1!= user.size(); dep1++) { + auto userObj = user.at(dep1); + std::string userObjStr = "User." + std::to_string(dep1); + setCoreParameter(userObjStr + ".Password", userObj.password); + setCoreParameter(userObjStr + ".Name", userObj.name); + setCoreParameter(userObjStr + ".Group", userObj.group); } } diff --git a/ehpc/src/model/BindAccountToClusterUserRequest.cc b/ehpc/src/model/BindAccountToClusterUserRequest.cc new file mode 100644 index 000000000..783ab10c7 --- /dev/null +++ b/ehpc/src/model/BindAccountToClusterUserRequest.cc @@ -0,0 +1,95 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed 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. + */ + +#include + +using AlibabaCloud::EHPC::Model::BindAccountToClusterUserRequest; + +BindAccountToClusterUserRequest::BindAccountToClusterUserRequest() : + RpcServiceRequest("ehpc", "2018-04-12", "BindAccountToClusterUser") +{ + setMethod(HttpRequest::Method::Get); +} + +BindAccountToClusterUserRequest::~BindAccountToClusterUserRequest() +{} + +std::string BindAccountToClusterUserRequest::getUserPwd()const +{ + return userPwd_; +} + +void BindAccountToClusterUserRequest::setUserPwd(const std::string& userPwd) +{ + userPwd_ = userPwd; + setCoreParameter("UserPwd", userPwd); +} + +std::string BindAccountToClusterUserRequest::getClusterId()const +{ + return clusterId_; +} + +void BindAccountToClusterUserRequest::setClusterId(const std::string& clusterId) +{ + clusterId_ = clusterId; + setCoreParameter("ClusterId", clusterId); +} + +std::string BindAccountToClusterUserRequest::getAccessKeyId()const +{ + return accessKeyId_; +} + +void BindAccountToClusterUserRequest::setAccessKeyId(const std::string& accessKeyId) +{ + accessKeyId_ = accessKeyId; + setCoreParameter("AccessKeyId", accessKeyId); +} + +std::string BindAccountToClusterUserRequest::getAccountName()const +{ + return accountName_; +} + +void BindAccountToClusterUserRequest::setAccountName(const std::string& accountName) +{ + accountName_ = accountName; + setCoreParameter("AccountName", accountName); +} + +std::string BindAccountToClusterUserRequest::getAccountUid()const +{ + return accountUid_; +} + +void BindAccountToClusterUserRequest::setAccountUid(const std::string& accountUid) +{ + accountUid_ = accountUid; + setCoreParameter("AccountUid", accountUid); +} + +std::string BindAccountToClusterUserRequest::getUserName()const +{ + return userName_; +} + +void BindAccountToClusterUserRequest::setUserName(const std::string& userName) +{ + userName_ = userName; + setCoreParameter("UserName", userName); +} + diff --git a/ehpc/src/model/BindAccountToClusterUserResult.cc b/ehpc/src/model/BindAccountToClusterUserResult.cc new file mode 100644 index 000000000..aa73ce2aa --- /dev/null +++ b/ehpc/src/model/BindAccountToClusterUserResult.cc @@ -0,0 +1,44 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed 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. + */ + +#include +#include + +using namespace AlibabaCloud::EHPC; +using namespace AlibabaCloud::EHPC::Model; + +BindAccountToClusterUserResult::BindAccountToClusterUserResult() : + ServiceResult() +{} + +BindAccountToClusterUserResult::BindAccountToClusterUserResult(const std::string &payload) : + ServiceResult() +{ + parse(payload); +} + +BindAccountToClusterUserResult::~BindAccountToClusterUserResult() +{} + +void BindAccountToClusterUserResult::parse(const std::string &payload) +{ + Json::Reader reader; + Json::Value value; + reader.parse(payload, value); + setRequestId(value["RequestId"].asString()); + +} + diff --git a/ehpc/src/model/CreateClusterRequest.cc b/ehpc/src/model/CreateClusterRequest.cc index a37bbabbd..7d1da5d83 100644 --- a/ehpc/src/model/CreateClusterRequest.cc +++ b/ehpc/src/model/CreateClusterRequest.cc @@ -20,7 +20,9 @@ using AlibabaCloud::EHPC::Model::CreateClusterRequest; CreateClusterRequest::CreateClusterRequest() : RpcServiceRequest("ehpc", "2018-04-12", "CreateCluster") -{} +{ + setMethod(HttpRequest::Method::Get); +} CreateClusterRequest::~CreateClusterRequest() {} @@ -33,19 +35,22 @@ std::vector CreateClusterRequest::getAd void CreateClusterRequest::setAdditionalVolumes(const std::vector& additionalVolumes) { additionalVolumes_ = additionalVolumes; - int i = 0; - for(int i = 0; i!= additionalVolumes.size(); i++) { - auto obj = additionalVolumes.at(i); - std::string str ="AdditionalVolumes."+ std::to_string(i); - setCoreParameter(str + ".VolumeType", obj.volumeType); - setCoreParameter(str + ".VolumeProtocol", obj.volumeProtocol); - setCoreParameter(str + ".LocalDirectory", obj.localDirectory); - setCoreParameter(str + ".RemoteDirectory", obj.remoteDirectory); - setCoreParameter(str + ".Roles", std::to_string(obj.roles)); - setCoreParameter(str + ".VolumeId", obj.volumeId); - setCoreParameter(str + ".VolumeMountpoint", obj.volumeMountpoint); - setCoreParameter(str + ".Location", obj.location); - setCoreParameter(str + ".JobQueue", obj.jobQueue); + for(int dep1 = 0; dep1!= additionalVolumes.size(); dep1++) { + auto additionalVolumesObj = additionalVolumes.at(dep1); + std::string additionalVolumesObjStr = "AdditionalVolumes." + std::to_string(dep1); + setCoreParameter(additionalVolumesObjStr + ".VolumeType", additionalVolumesObj.volumeType); + setCoreParameter(additionalVolumesObjStr + ".VolumeProtocol", additionalVolumesObj.volumeProtocol); + setCoreParameter(additionalVolumesObjStr + ".LocalDirectory", additionalVolumesObj.localDirectory); + setCoreParameter(additionalVolumesObjStr + ".RemoteDirectory", additionalVolumesObj.remoteDirectory); + for(int dep2 = 0; dep2!= additionalVolumesObj.roles.size(); dep2++) { + auto rolesObj = additionalVolumesObj.roles.at(dep2); + std::string rolesObjStr = additionalVolumesObjStr + "Roles." + std::to_string(dep2); + setCoreParameter(rolesObjStr + ".Name", rolesObj.name); + } + setCoreParameter(additionalVolumesObjStr + ".VolumeId", additionalVolumesObj.volumeId); + setCoreParameter(additionalVolumesObjStr + ".VolumeMountpoint", additionalVolumesObj.volumeMountpoint); + setCoreParameter(additionalVolumesObjStr + ".Location", additionalVolumesObj.location); + setCoreParameter(additionalVolumesObjStr + ".JobQueue", additionalVolumesObj.jobQueue); } } @@ -244,12 +249,11 @@ std::vector CreateClusterRequest::getPo void CreateClusterRequest::setPostInstallScript(const std::vector& postInstallScript) { postInstallScript_ = postInstallScript; - int i = 0; - for(int i = 0; i!= postInstallScript.size(); i++) { - auto obj = postInstallScript.at(i); - std::string str ="PostInstallScript."+ std::to_string(i); - setCoreParameter(str + ".Args", obj.args); - setCoreParameter(str + ".Url", obj.url); + for(int dep1 = 0; dep1!= postInstallScript.size(); dep1++) { + auto postInstallScriptObj = postInstallScript.at(dep1); + std::string postInstallScriptObjStr = "PostInstallScript." + std::to_string(dep1); + setCoreParameter(postInstallScriptObjStr + ".Args", postInstallScriptObj.args); + setCoreParameter(postInstallScriptObjStr + ".Url", postInstallScriptObj.url); } } @@ -440,6 +444,17 @@ void CreateClusterRequest::setSystemDiskType(const std::string& systemDiskType) setCoreParameter("SystemDiskType", systemDiskType); } +bool CreateClusterRequest::getIsComputeOnecs()const +{ + return isComputeOnecs_; +} + +void CreateClusterRequest::setIsComputeOnecs(bool isComputeOnecs) +{ + isComputeOnecs_ = isComputeOnecs; + setCoreParameter("IsComputeOnecs", isComputeOnecs ? "true" : "false"); +} + std::string CreateClusterRequest::getVolumeProtocol()const { return volumeProtocol_; @@ -481,11 +496,10 @@ std::vector CreateClusterRequest::getApplicat void CreateClusterRequest::setApplication(const std::vector& application) { application_ = application; - int i = 0; - for(int i = 0; i!= application.size(); i++) { - auto obj = application.at(i); - std::string str ="Application."+ std::to_string(i); - setCoreParameter(str + ".Tag", obj.tag); + for(int dep1 = 0; dep1!= application.size(); dep1++) { + auto applicationObj = application.at(dep1); + std::string applicationObjStr = "Application." + std::to_string(dep1); + setCoreParameter(applicationObjStr + ".Tag", applicationObj.tag); } } diff --git a/ehpc/src/model/CreateGWSClusterRequest.cc b/ehpc/src/model/CreateGWSClusterRequest.cc index a1941f25b..1cca5124b 100644 --- a/ehpc/src/model/CreateGWSClusterRequest.cc +++ b/ehpc/src/model/CreateGWSClusterRequest.cc @@ -20,7 +20,9 @@ using AlibabaCloud::EHPC::Model::CreateGWSClusterRequest; CreateGWSClusterRequest::CreateGWSClusterRequest() : RpcServiceRequest("ehpc", "2018-04-12", "CreateGWSCluster") -{} +{ + setMethod(HttpRequest::Method::Get); +} CreateGWSClusterRequest::~CreateGWSClusterRequest() {} diff --git a/ehpc/src/model/CreateGWSImageRequest.cc b/ehpc/src/model/CreateGWSImageRequest.cc index c6fdcf79d..9f4c55ff9 100644 --- a/ehpc/src/model/CreateGWSImageRequest.cc +++ b/ehpc/src/model/CreateGWSImageRequest.cc @@ -20,7 +20,9 @@ using AlibabaCloud::EHPC::Model::CreateGWSImageRequest; CreateGWSImageRequest::CreateGWSImageRequest() : RpcServiceRequest("ehpc", "2018-04-12", "CreateGWSImage") -{} +{ + setMethod(HttpRequest::Method::Get); +} CreateGWSImageRequest::~CreateGWSImageRequest() {} diff --git a/ehpc/src/model/CreateGWSInstanceRequest.cc b/ehpc/src/model/CreateGWSInstanceRequest.cc index 74739ac38..c5ba6313d 100644 --- a/ehpc/src/model/CreateGWSInstanceRequest.cc +++ b/ehpc/src/model/CreateGWSInstanceRequest.cc @@ -20,7 +20,9 @@ using AlibabaCloud::EHPC::Model::CreateGWSInstanceRequest; CreateGWSInstanceRequest::CreateGWSInstanceRequest() : RpcServiceRequest("ehpc", "2018-04-12", "CreateGWSInstance") -{} +{ + setMethod(HttpRequest::Method::Get); +} CreateGWSInstanceRequest::~CreateGWSInstanceRequest() {} diff --git a/ehpc/src/model/CreateHybridClusterRequest.cc b/ehpc/src/model/CreateHybridClusterRequest.cc index afb2b1c22..64d1ffabc 100644 --- a/ehpc/src/model/CreateHybridClusterRequest.cc +++ b/ehpc/src/model/CreateHybridClusterRequest.cc @@ -20,7 +20,9 @@ using AlibabaCloud::EHPC::Model::CreateHybridClusterRequest; CreateHybridClusterRequest::CreateHybridClusterRequest() : RpcServiceRequest("ehpc", "2018-04-12", "CreateHybridCluster") -{} +{ + setMethod(HttpRequest::Method::Get); +} CreateHybridClusterRequest::~CreateHybridClusterRequest() {} @@ -242,12 +244,11 @@ std::vector CreateHybridClusterRe void CreateHybridClusterRequest::setPostInstallScript(const std::vector& postInstallScript) { postInstallScript_ = postInstallScript; - int i = 0; - for(int i = 0; i!= postInstallScript.size(); i++) { - auto obj = postInstallScript.at(i); - std::string str ="PostInstallScript."+ std::to_string(i); - setCoreParameter(str + ".Args", obj.args); - setCoreParameter(str + ".Url", obj.url); + for(int dep1 = 0; dep1!= postInstallScript.size(); dep1++) { + auto postInstallScriptObj = postInstallScript.at(dep1); + std::string postInstallScriptObjStr = "PostInstallScript." + std::to_string(dep1); + setCoreParameter(postInstallScriptObjStr + ".Args", postInstallScriptObj.args); + setCoreParameter(postInstallScriptObjStr + ".Url", postInstallScriptObj.url); } } @@ -270,15 +271,14 @@ std::vector CreateHybridClusterRequest::getNo void CreateHybridClusterRequest::setNodes(const std::vector& nodes) { nodes_ = nodes; - int i = 0; - for(int i = 0; i!= nodes.size(); i++) { - auto obj = nodes.at(i); - std::string str ="Nodes."+ std::to_string(i); - setCoreParameter(str + ".IpAddress", obj.ipAddress); - setCoreParameter(str + ".HostName", obj.hostName); - setCoreParameter(str + ".Role", obj.role); - setCoreParameter(str + ".AccountType", obj.accountType); - setCoreParameter(str + ".SchedulerType", obj.schedulerType); + for(int dep1 = 0; dep1!= nodes.size(); dep1++) { + auto nodesObj = nodes.at(dep1); + std::string nodesObjStr = "Nodes." + std::to_string(dep1); + setCoreParameter(nodesObjStr + ".IpAddress", nodesObj.ipAddress); + setCoreParameter(nodesObjStr + ".HostName", nodesObj.hostName); + setCoreParameter(nodesObjStr + ".Role", nodesObj.role); + setCoreParameter(nodesObjStr + ".AccountType", nodesObj.accountType); + setCoreParameter(nodesObjStr + ".SchedulerType", nodesObj.schedulerType); } } @@ -290,11 +290,10 @@ std::vector CreateHybridClusterRequest: void CreateHybridClusterRequest::setApplication(const std::vector& application) { application_ = application; - int i = 0; - for(int i = 0; i!= application.size(); i++) { - auto obj = application.at(i); - std::string str ="Application."+ std::to_string(i); - setCoreParameter(str + ".Tag", obj.tag); + for(int dep1 = 0; dep1!= application.size(); dep1++) { + auto applicationObj = application.at(dep1); + std::string applicationObjStr = "Application." + std::to_string(dep1); + setCoreParameter(applicationObjStr + ".Tag", applicationObj.tag); } } diff --git a/ehpc/src/model/CreateJobFileRequest.cc b/ehpc/src/model/CreateJobFileRequest.cc index d92103544..8256001cc 100644 --- a/ehpc/src/model/CreateJobFileRequest.cc +++ b/ehpc/src/model/CreateJobFileRequest.cc @@ -20,7 +20,9 @@ using AlibabaCloud::EHPC::Model::CreateJobFileRequest; CreateJobFileRequest::CreateJobFileRequest() : RpcServiceRequest("ehpc", "2018-04-12", "CreateJobFile") -{} +{ + setMethod(HttpRequest::Method::Get); +} CreateJobFileRequest::~CreateJobFileRequest() {} diff --git a/ehpc/src/model/CreateJobTemplateRequest.cc b/ehpc/src/model/CreateJobTemplateRequest.cc index bac3ae8aa..3169c0866 100644 --- a/ehpc/src/model/CreateJobTemplateRequest.cc +++ b/ehpc/src/model/CreateJobTemplateRequest.cc @@ -20,7 +20,9 @@ using AlibabaCloud::EHPC::Model::CreateJobTemplateRequest; CreateJobTemplateRequest::CreateJobTemplateRequest() : RpcServiceRequest("ehpc", "2018-04-12", "CreateJobTemplate") -{} +{ + setMethod(HttpRequest::Method::Get); +} CreateJobTemplateRequest::~CreateJobTemplateRequest() {} diff --git a/ehpc/src/model/DeleteClusterRequest.cc b/ehpc/src/model/DeleteClusterRequest.cc index c56fb1270..85df022c1 100644 --- a/ehpc/src/model/DeleteClusterRequest.cc +++ b/ehpc/src/model/DeleteClusterRequest.cc @@ -20,7 +20,9 @@ using AlibabaCloud::EHPC::Model::DeleteClusterRequest; DeleteClusterRequest::DeleteClusterRequest() : RpcServiceRequest("ehpc", "2018-04-12", "DeleteCluster") -{} +{ + setMethod(HttpRequest::Method::Get); +} DeleteClusterRequest::~DeleteClusterRequest() {} diff --git a/ehpc/src/model/DeleteContainerAppsRequest.cc b/ehpc/src/model/DeleteContainerAppsRequest.cc index 5936e389b..47ffb331b 100644 --- a/ehpc/src/model/DeleteContainerAppsRequest.cc +++ b/ehpc/src/model/DeleteContainerAppsRequest.cc @@ -20,7 +20,9 @@ using AlibabaCloud::EHPC::Model::DeleteContainerAppsRequest; DeleteContainerAppsRequest::DeleteContainerAppsRequest() : RpcServiceRequest("ehpc", "2018-04-12", "DeleteContainerApps") -{} +{ + setMethod(HttpRequest::Method::Get); +} DeleteContainerAppsRequest::~DeleteContainerAppsRequest() {} @@ -33,11 +35,10 @@ std::vector DeleteContainerAppsRequest void DeleteContainerAppsRequest::setContainerApp(const std::vector& containerApp) { containerApp_ = containerApp; - int i = 0; - for(int i = 0; i!= containerApp.size(); i++) { - auto obj = containerApp.at(i); - std::string str ="ContainerApp."+ std::to_string(i); - setCoreParameter(str + ".Id", obj.id); + for(int dep1 = 0; dep1!= containerApp.size(); dep1++) { + auto containerAppObj = containerApp.at(dep1); + std::string containerAppObjStr = "ContainerApp." + std::to_string(dep1); + setCoreParameter(containerAppObjStr + ".Id", containerAppObj.id); } } diff --git a/ehpc/src/model/DeleteGWSClusterRequest.cc b/ehpc/src/model/DeleteGWSClusterRequest.cc index b809862d5..4d8802652 100644 --- a/ehpc/src/model/DeleteGWSClusterRequest.cc +++ b/ehpc/src/model/DeleteGWSClusterRequest.cc @@ -20,7 +20,9 @@ using AlibabaCloud::EHPC::Model::DeleteGWSClusterRequest; DeleteGWSClusterRequest::DeleteGWSClusterRequest() : RpcServiceRequest("ehpc", "2018-04-12", "DeleteGWSCluster") -{} +{ + setMethod(HttpRequest::Method::Get); +} DeleteGWSClusterRequest::~DeleteGWSClusterRequest() {} diff --git a/ehpc/src/model/DeleteGWSInstanceRequest.cc b/ehpc/src/model/DeleteGWSInstanceRequest.cc index a6e05cc17..1726ed6f8 100644 --- a/ehpc/src/model/DeleteGWSInstanceRequest.cc +++ b/ehpc/src/model/DeleteGWSInstanceRequest.cc @@ -20,7 +20,9 @@ using AlibabaCloud::EHPC::Model::DeleteGWSInstanceRequest; DeleteGWSInstanceRequest::DeleteGWSInstanceRequest() : RpcServiceRequest("ehpc", "2018-04-12", "DeleteGWSInstance") -{} +{ + setMethod(HttpRequest::Method::Get); +} DeleteGWSInstanceRequest::~DeleteGWSInstanceRequest() {} diff --git a/ehpc/src/model/DeleteImageRequest.cc b/ehpc/src/model/DeleteImageRequest.cc index 4f802ca16..84ed533d6 100644 --- a/ehpc/src/model/DeleteImageRequest.cc +++ b/ehpc/src/model/DeleteImageRequest.cc @@ -20,7 +20,9 @@ using AlibabaCloud::EHPC::Model::DeleteImageRequest; DeleteImageRequest::DeleteImageRequest() : RpcServiceRequest("ehpc", "2018-04-12", "DeleteImage") -{} +{ + setMethod(HttpRequest::Method::Get); +} DeleteImageRequest::~DeleteImageRequest() {} diff --git a/ehpc/src/model/DeleteJobTemplatesRequest.cc b/ehpc/src/model/DeleteJobTemplatesRequest.cc index 39535fce6..2c054ec87 100644 --- a/ehpc/src/model/DeleteJobTemplatesRequest.cc +++ b/ehpc/src/model/DeleteJobTemplatesRequest.cc @@ -20,7 +20,9 @@ using AlibabaCloud::EHPC::Model::DeleteJobTemplatesRequest; DeleteJobTemplatesRequest::DeleteJobTemplatesRequest() : RpcServiceRequest("ehpc", "2018-04-12", "DeleteJobTemplates") -{} +{ + setMethod(HttpRequest::Method::Get); +} DeleteJobTemplatesRequest::~DeleteJobTemplatesRequest() {} diff --git a/ehpc/src/model/DeleteJobsRequest.cc b/ehpc/src/model/DeleteJobsRequest.cc index 8319e5e1b..0848ff471 100644 --- a/ehpc/src/model/DeleteJobsRequest.cc +++ b/ehpc/src/model/DeleteJobsRequest.cc @@ -20,7 +20,9 @@ using AlibabaCloud::EHPC::Model::DeleteJobsRequest; DeleteJobsRequest::DeleteJobsRequest() : RpcServiceRequest("ehpc", "2018-04-12", "DeleteJobs") -{} +{ + setMethod(HttpRequest::Method::Get); +} DeleteJobsRequest::~DeleteJobsRequest() {} diff --git a/ehpc/src/model/DeleteNodesRequest.cc b/ehpc/src/model/DeleteNodesRequest.cc index 450d16a44..82447c40e 100644 --- a/ehpc/src/model/DeleteNodesRequest.cc +++ b/ehpc/src/model/DeleteNodesRequest.cc @@ -20,7 +20,9 @@ using AlibabaCloud::EHPC::Model::DeleteNodesRequest; DeleteNodesRequest::DeleteNodesRequest() : RpcServiceRequest("ehpc", "2018-04-12", "DeleteNodes") -{} +{ + setMethod(HttpRequest::Method::Get); +} DeleteNodesRequest::~DeleteNodesRequest() {} @@ -33,11 +35,10 @@ std::vector DeleteNodesRequest::getInstance()const void DeleteNodesRequest::setInstance(const std::vector& instance) { instance_ = instance; - int i = 0; - for(int i = 0; i!= instance.size(); i++) { - auto obj = instance.at(i); - std::string str ="Instance."+ std::to_string(i); - setCoreParameter(str + ".Id", obj.id); + for(int dep1 = 0; dep1!= instance.size(); dep1++) { + auto instanceObj = instance.at(dep1); + std::string instanceObjStr = "Instance." + std::to_string(dep1); + setCoreParameter(instanceObjStr + ".Id", instanceObj.id); } } diff --git a/ehpc/src/model/DeleteQueueRequest.cc b/ehpc/src/model/DeleteQueueRequest.cc index b0a8214ce..1f4a94481 100644 --- a/ehpc/src/model/DeleteQueueRequest.cc +++ b/ehpc/src/model/DeleteQueueRequest.cc @@ -20,7 +20,9 @@ using AlibabaCloud::EHPC::Model::DeleteQueueRequest; DeleteQueueRequest::DeleteQueueRequest() : RpcServiceRequest("ehpc", "2018-04-12", "DeleteQueue") -{} +{ + setMethod(HttpRequest::Method::Get); +} DeleteQueueRequest::~DeleteQueueRequest() {} diff --git a/ehpc/src/model/DeleteUsersRequest.cc b/ehpc/src/model/DeleteUsersRequest.cc index 9b949d6a2..d864f1360 100644 --- a/ehpc/src/model/DeleteUsersRequest.cc +++ b/ehpc/src/model/DeleteUsersRequest.cc @@ -20,7 +20,9 @@ using AlibabaCloud::EHPC::Model::DeleteUsersRequest; DeleteUsersRequest::DeleteUsersRequest() : RpcServiceRequest("ehpc", "2018-04-12", "DeleteUsers") -{} +{ + setMethod(HttpRequest::Method::Get); +} DeleteUsersRequest::~DeleteUsersRequest() {} @@ -55,11 +57,10 @@ std::vector DeleteUsersRequest::getUser()const void DeleteUsersRequest::setUser(const std::vector& user) { user_ = user; - int i = 0; - for(int i = 0; i!= user.size(); i++) { - auto obj = user.at(i); - std::string str ="User."+ std::to_string(i); - setCoreParameter(str + ".Name", obj.name); + for(int dep1 = 0; dep1!= user.size(); dep1++) { + auto userObj = user.at(dep1); + std::string userObjStr = "User." + std::to_string(dep1); + setCoreParameter(userObjStr + ".Name", userObj.name); } } diff --git a/ehpc/src/model/DescribeAutoScaleConfigRequest.cc b/ehpc/src/model/DescribeAutoScaleConfigRequest.cc index dbca654ba..eeabab511 100644 --- a/ehpc/src/model/DescribeAutoScaleConfigRequest.cc +++ b/ehpc/src/model/DescribeAutoScaleConfigRequest.cc @@ -20,7 +20,9 @@ using AlibabaCloud::EHPC::Model::DescribeAutoScaleConfigRequest; DescribeAutoScaleConfigRequest::DescribeAutoScaleConfigRequest() : RpcServiceRequest("ehpc", "2018-04-12", "DescribeAutoScaleConfig") -{} +{ + setMethod(HttpRequest::Method::Get); +} DescribeAutoScaleConfigRequest::~DescribeAutoScaleConfigRequest() {} diff --git a/ehpc/src/model/DescribeClusterRequest.cc b/ehpc/src/model/DescribeClusterRequest.cc index 8695812fb..60ad88a62 100644 --- a/ehpc/src/model/DescribeClusterRequest.cc +++ b/ehpc/src/model/DescribeClusterRequest.cc @@ -20,7 +20,9 @@ using AlibabaCloud::EHPC::Model::DescribeClusterRequest; DescribeClusterRequest::DescribeClusterRequest() : RpcServiceRequest("ehpc", "2018-04-12", "DescribeCluster") -{} +{ + setMethod(HttpRequest::Method::Get); +} DescribeClusterRequest::~DescribeClusterRequest() {} diff --git a/ehpc/src/model/DescribeContainerAppRequest.cc b/ehpc/src/model/DescribeContainerAppRequest.cc index c41703363..ec7ceaf88 100644 --- a/ehpc/src/model/DescribeContainerAppRequest.cc +++ b/ehpc/src/model/DescribeContainerAppRequest.cc @@ -20,7 +20,9 @@ using AlibabaCloud::EHPC::Model::DescribeContainerAppRequest; DescribeContainerAppRequest::DescribeContainerAppRequest() : RpcServiceRequest("ehpc", "2018-04-12", "DescribeContainerApp") -{} +{ + setMethod(HttpRequest::Method::Get); +} DescribeContainerAppRequest::~DescribeContainerAppRequest() {} diff --git a/ehpc/src/model/DescribeGWSClustersRequest.cc b/ehpc/src/model/DescribeGWSClustersRequest.cc index 79db54703..f340bfbdc 100644 --- a/ehpc/src/model/DescribeGWSClustersRequest.cc +++ b/ehpc/src/model/DescribeGWSClustersRequest.cc @@ -20,7 +20,9 @@ using AlibabaCloud::EHPC::Model::DescribeGWSClustersRequest; DescribeGWSClustersRequest::DescribeGWSClustersRequest() : RpcServiceRequest("ehpc", "2018-04-12", "DescribeGWSClusters") -{} +{ + setMethod(HttpRequest::Method::Get); +} DescribeGWSClustersRequest::~DescribeGWSClustersRequest() {} diff --git a/ehpc/src/model/DescribeGWSImagesRequest.cc b/ehpc/src/model/DescribeGWSImagesRequest.cc index 0f687b408..a70a4047d 100644 --- a/ehpc/src/model/DescribeGWSImagesRequest.cc +++ b/ehpc/src/model/DescribeGWSImagesRequest.cc @@ -20,7 +20,9 @@ using AlibabaCloud::EHPC::Model::DescribeGWSImagesRequest; DescribeGWSImagesRequest::DescribeGWSImagesRequest() : RpcServiceRequest("ehpc", "2018-04-12", "DescribeGWSImages") -{} +{ + setMethod(HttpRequest::Method::Get); +} DescribeGWSImagesRequest::~DescribeGWSImagesRequest() {} diff --git a/ehpc/src/model/DescribeGWSInstancesRequest.cc b/ehpc/src/model/DescribeGWSInstancesRequest.cc index 600e8e884..a21d5344e 100644 --- a/ehpc/src/model/DescribeGWSInstancesRequest.cc +++ b/ehpc/src/model/DescribeGWSInstancesRequest.cc @@ -20,7 +20,9 @@ using AlibabaCloud::EHPC::Model::DescribeGWSInstancesRequest; DescribeGWSInstancesRequest::DescribeGWSInstancesRequest() : RpcServiceRequest("ehpc", "2018-04-12", "DescribeGWSInstances") -{} +{ + setMethod(HttpRequest::Method::Get); +} DescribeGWSInstancesRequest::~DescribeGWSInstancesRequest() {} diff --git a/ehpc/src/model/DescribeImageGatewayConfigRequest.cc b/ehpc/src/model/DescribeImageGatewayConfigRequest.cc index 3afad7fbd..32b299bfe 100644 --- a/ehpc/src/model/DescribeImageGatewayConfigRequest.cc +++ b/ehpc/src/model/DescribeImageGatewayConfigRequest.cc @@ -20,7 +20,9 @@ using AlibabaCloud::EHPC::Model::DescribeImageGatewayConfigRequest; DescribeImageGatewayConfigRequest::DescribeImageGatewayConfigRequest() : RpcServiceRequest("ehpc", "2018-04-12", "DescribeImageGatewayConfig") -{} +{ + setMethod(HttpRequest::Method::Get); +} DescribeImageGatewayConfigRequest::~DescribeImageGatewayConfigRequest() {} diff --git a/ehpc/src/model/DescribeImagePriceRequest.cc b/ehpc/src/model/DescribeImagePriceRequest.cc index 1993230ab..59001b5d0 100644 --- a/ehpc/src/model/DescribeImagePriceRequest.cc +++ b/ehpc/src/model/DescribeImagePriceRequest.cc @@ -20,7 +20,9 @@ using AlibabaCloud::EHPC::Model::DescribeImagePriceRequest; DescribeImagePriceRequest::DescribeImagePriceRequest() : RpcServiceRequest("ehpc", "2018-04-12", "DescribeImagePrice") -{} +{ + setMethod(HttpRequest::Method::Get); +} DescribeImagePriceRequest::~DescribeImagePriceRequest() {} diff --git a/ehpc/src/model/DescribeImageRequest.cc b/ehpc/src/model/DescribeImageRequest.cc index d6fc83bd2..21e23307c 100644 --- a/ehpc/src/model/DescribeImageRequest.cc +++ b/ehpc/src/model/DescribeImageRequest.cc @@ -20,7 +20,9 @@ using AlibabaCloud::EHPC::Model::DescribeImageRequest; DescribeImageRequest::DescribeImageRequest() : RpcServiceRequest("ehpc", "2018-04-12", "DescribeImage") -{} +{ + setMethod(HttpRequest::Method::Get); +} DescribeImageRequest::~DescribeImageRequest() {} diff --git a/ehpc/src/model/DescribeJobRequest.cc b/ehpc/src/model/DescribeJobRequest.cc index 564b5495c..c7e2b0fae 100644 --- a/ehpc/src/model/DescribeJobRequest.cc +++ b/ehpc/src/model/DescribeJobRequest.cc @@ -20,7 +20,9 @@ using AlibabaCloud::EHPC::Model::DescribeJobRequest; DescribeJobRequest::DescribeJobRequest() : RpcServiceRequest("ehpc", "2018-04-12", "DescribeJob") -{} +{ + setMethod(HttpRequest::Method::Get); +} DescribeJobRequest::~DescribeJobRequest() {} diff --git a/ehpc/src/model/DescribeNFSClientStatusRequest.cc b/ehpc/src/model/DescribeNFSClientStatusRequest.cc index 8a14ea6d2..c1a82b1ca 100644 --- a/ehpc/src/model/DescribeNFSClientStatusRequest.cc +++ b/ehpc/src/model/DescribeNFSClientStatusRequest.cc @@ -20,7 +20,9 @@ using AlibabaCloud::EHPC::Model::DescribeNFSClientStatusRequest; DescribeNFSClientStatusRequest::DescribeNFSClientStatusRequest() : RpcServiceRequest("ehpc", "2018-04-12", "DescribeNFSClientStatus") -{} +{ + setMethod(HttpRequest::Method::Get); +} DescribeNFSClientStatusRequest::~DescribeNFSClientStatusRequest() {} diff --git a/ehpc/src/model/DescribePriceRequest.cc b/ehpc/src/model/DescribePriceRequest.cc index 6e1bf1eb4..db2aad23b 100644 --- a/ehpc/src/model/DescribePriceRequest.cc +++ b/ehpc/src/model/DescribePriceRequest.cc @@ -20,7 +20,9 @@ using AlibabaCloud::EHPC::Model::DescribePriceRequest; DescribePriceRequest::DescribePriceRequest() : RpcServiceRequest("ehpc", "2018-04-12", "DescribePrice") -{} +{ + setMethod(HttpRequest::Method::Get); +} DescribePriceRequest::~DescribePriceRequest() {} @@ -33,17 +35,16 @@ std::vector DescribePriceRequest::getCommodit void DescribePriceRequest::setCommodities(const std::vector& commodities) { commodities_ = commodities; - int i = 0; - for(int i = 0; i!= commodities.size(); i++) { - auto obj = commodities.at(i); - std::string str ="Commodities."+ std::to_string(i); - setCoreParameter(str + ".Amount", std::to_string(obj.amount)); - setCoreParameter(str + ".Period", std::to_string(obj.period)); - setCoreParameter(str + ".NodeType", obj.nodeType); - setCoreParameter(str + ".SystemDiskCategory", obj.systemDiskCategory); - setCoreParameter(str + ".SystemDiskSize", std::to_string(obj.systemDiskSize)); - setCoreParameter(str + ".InstanceType", obj.instanceType); - setCoreParameter(str + ".NetworkType", obj.networkType); + for(int dep1 = 0; dep1!= commodities.size(); dep1++) { + auto commoditiesObj = commodities.at(dep1); + std::string commoditiesObjStr = "Commodities." + std::to_string(dep1); + setCoreParameter(commoditiesObjStr + ".Amount", std::to_string(commoditiesObj.amount)); + setCoreParameter(commoditiesObjStr + ".Period", std::to_string(commoditiesObj.period)); + setCoreParameter(commoditiesObjStr + ".NodeType", commoditiesObj.nodeType); + setCoreParameter(commoditiesObjStr + ".SystemDiskCategory", commoditiesObj.systemDiskCategory); + setCoreParameter(commoditiesObjStr + ".SystemDiskSize", std::to_string(commoditiesObj.systemDiskSize)); + setCoreParameter(commoditiesObjStr + ".InstanceType", commoditiesObj.instanceType); + setCoreParameter(commoditiesObjStr + ".NetworkType", commoditiesObj.networkType); } } diff --git a/ehpc/src/model/EditJobTemplateRequest.cc b/ehpc/src/model/EditJobTemplateRequest.cc index 48bd12355..aa28c06fa 100644 --- a/ehpc/src/model/EditJobTemplateRequest.cc +++ b/ehpc/src/model/EditJobTemplateRequest.cc @@ -20,7 +20,9 @@ using AlibabaCloud::EHPC::Model::EditJobTemplateRequest; EditJobTemplateRequest::EditJobTemplateRequest() : RpcServiceRequest("ehpc", "2018-04-12", "EditJobTemplate") -{} +{ + setMethod(HttpRequest::Method::Get); +} EditJobTemplateRequest::~EditJobTemplateRequest() {} diff --git a/ehpc/src/model/GetAccountingReportRequest.cc b/ehpc/src/model/GetAccountingReportRequest.cc index ee4ba1b12..e4214eb9b 100644 --- a/ehpc/src/model/GetAccountingReportRequest.cc +++ b/ehpc/src/model/GetAccountingReportRequest.cc @@ -20,7 +20,9 @@ using AlibabaCloud::EHPC::Model::GetAccountingReportRequest; GetAccountingReportRequest::GetAccountingReportRequest() : RpcServiceRequest("ehpc", "2018-04-12", "GetAccountingReport") -{} +{ + setMethod(HttpRequest::Method::Get); +} GetAccountingReportRequest::~GetAccountingReportRequest() {} @@ -47,6 +49,17 @@ void GetAccountingReportRequest::setEndTime(int endTime) setCoreParameter("EndTime", std::to_string(endTime)); } +std::string GetAccountingReportRequest::getFilterValue()const +{ + return filterValue_; +} + +void GetAccountingReportRequest::setFilterValue(const std::string& filterValue) +{ + filterValue_ = filterValue; + setCoreParameter("FilterValue", filterValue); +} + std::string GetAccountingReportRequest::getClusterId()const { return clusterId_; diff --git a/ehpc/src/model/GetAccountingReportResult.cc b/ehpc/src/model/GetAccountingReportResult.cc index 570d595c7..5f95862cd 100644 --- a/ehpc/src/model/GetAccountingReportResult.cc +++ b/ehpc/src/model/GetAccountingReportResult.cc @@ -39,10 +39,11 @@ void GetAccountingReportResult::parse(const std::string &payload) Json::Value value; reader.parse(payload, value); setRequestId(value["RequestId"].asString()); + auto allData = value["Data"]["Data"]; + for (const auto &item : allData) + data_.push_back(item.asString()); if(!value["Metrics"].isNull()) metrics_ = value["Metrics"].asString(); - if(!value["Data"].isNull()) - data_ = value["Data"].asString(); } @@ -51,7 +52,7 @@ std::string GetAccountingReportResult::getMetrics()const return metrics_; } -std::string GetAccountingReportResult::getData()const +std::vector GetAccountingReportResult::getData()const { return data_; } diff --git a/ehpc/src/model/GetAutoScaleConfigRequest.cc b/ehpc/src/model/GetAutoScaleConfigRequest.cc index e7836d433..57b6be559 100644 --- a/ehpc/src/model/GetAutoScaleConfigRequest.cc +++ b/ehpc/src/model/GetAutoScaleConfigRequest.cc @@ -20,7 +20,9 @@ using AlibabaCloud::EHPC::Model::GetAutoScaleConfigRequest; GetAutoScaleConfigRequest::GetAutoScaleConfigRequest() : RpcServiceRequest("ehpc", "2018-04-12", "GetAutoScaleConfig") -{} +{ + setMethod(HttpRequest::Method::Get); +} GetAutoScaleConfigRequest::~GetAutoScaleConfigRequest() {} diff --git a/ehpc/src/model/GetAutoScaleConfigResult.cc b/ehpc/src/model/GetAutoScaleConfigResult.cc index 738f2968d..17a98b3cd 100644 --- a/ehpc/src/model/GetAutoScaleConfigResult.cc +++ b/ehpc/src/model/GetAutoScaleConfigResult.cc @@ -71,6 +71,8 @@ void GetAutoScaleConfigResult::parse(const std::string &payload) instanceTypesObject.zoneId = allQueuesNodeInstanceTypesInstanceTypeInfo["ZoneId"].asString(); if(!allQueuesNodeInstanceTypesInstanceTypeInfo["VSwitchId"].isNull()) instanceTypesObject.vSwitchId = allQueuesNodeInstanceTypesInstanceTypeInfo["VSwitchId"].asString(); + if(!allQueuesNodeInstanceTypesInstanceTypeInfo["HostNamePrefix"].isNull()) + instanceTypesObject.hostNamePrefix = allQueuesNodeInstanceTypesInstanceTypeInfo["HostNamePrefix"].asString(); queuesObject.instanceTypes.push_back(instanceTypesObject); } queues_.push_back(queuesObject); diff --git a/ehpc/src/model/GetCloudMetricLogsRequest.cc b/ehpc/src/model/GetCloudMetricLogsRequest.cc index 7c7e94bfa..9aaab88a0 100644 --- a/ehpc/src/model/GetCloudMetricLogsRequest.cc +++ b/ehpc/src/model/GetCloudMetricLogsRequest.cc @@ -20,7 +20,9 @@ using AlibabaCloud::EHPC::Model::GetCloudMetricLogsRequest; GetCloudMetricLogsRequest::GetCloudMetricLogsRequest() : RpcServiceRequest("ehpc", "2018-04-12", "GetCloudMetricLogs") -{} +{ + setMethod(HttpRequest::Method::Get); +} GetCloudMetricLogsRequest::~GetCloudMetricLogsRequest() {} diff --git a/ehpc/src/model/GetCloudMetricProfilingRequest.cc b/ehpc/src/model/GetCloudMetricProfilingRequest.cc index 65c56b572..6ba6c820b 100644 --- a/ehpc/src/model/GetCloudMetricProfilingRequest.cc +++ b/ehpc/src/model/GetCloudMetricProfilingRequest.cc @@ -20,7 +20,9 @@ using AlibabaCloud::EHPC::Model::GetCloudMetricProfilingRequest; GetCloudMetricProfilingRequest::GetCloudMetricProfilingRequest() : RpcServiceRequest("ehpc", "2018-04-12", "GetCloudMetricProfiling") -{} +{ + setMethod(HttpRequest::Method::Get); +} GetCloudMetricProfilingRequest::~GetCloudMetricProfilingRequest() {} diff --git a/ehpc/src/model/GetClusterVolumesRequest.cc b/ehpc/src/model/GetClusterVolumesRequest.cc index f603b6cd6..1b2fa5c75 100644 --- a/ehpc/src/model/GetClusterVolumesRequest.cc +++ b/ehpc/src/model/GetClusterVolumesRequest.cc @@ -20,7 +20,9 @@ using AlibabaCloud::EHPC::Model::GetClusterVolumesRequest; GetClusterVolumesRequest::GetClusterVolumesRequest() : RpcServiceRequest("ehpc", "2018-04-12", "GetClusterVolumes") -{} +{ + setMethod(HttpRequest::Method::Get); +} GetClusterVolumesRequest::~GetClusterVolumesRequest() {} diff --git a/ehpc/src/model/GetGWSConnectTicketRequest.cc b/ehpc/src/model/GetGWSConnectTicketRequest.cc index 6c07888b4..134ef55a9 100644 --- a/ehpc/src/model/GetGWSConnectTicketRequest.cc +++ b/ehpc/src/model/GetGWSConnectTicketRequest.cc @@ -20,7 +20,9 @@ using AlibabaCloud::EHPC::Model::GetGWSConnectTicketRequest; GetGWSConnectTicketRequest::GetGWSConnectTicketRequest() : RpcServiceRequest("ehpc", "2018-04-12", "GetGWSConnectTicket") -{} +{ + setMethod(HttpRequest::Method::Get); +} GetGWSConnectTicketRequest::~GetGWSConnectTicketRequest() {} diff --git a/ehpc/src/model/GetHybridClusterConfigRequest.cc b/ehpc/src/model/GetHybridClusterConfigRequest.cc index 945d63b0f..41d27834e 100644 --- a/ehpc/src/model/GetHybridClusterConfigRequest.cc +++ b/ehpc/src/model/GetHybridClusterConfigRequest.cc @@ -20,7 +20,9 @@ using AlibabaCloud::EHPC::Model::GetHybridClusterConfigRequest; GetHybridClusterConfigRequest::GetHybridClusterConfigRequest() : RpcServiceRequest("ehpc", "2018-04-12", "GetHybridClusterConfig") -{} +{ + setMethod(HttpRequest::Method::Get); +} GetHybridClusterConfigRequest::~GetHybridClusterConfigRequest() {} diff --git a/ehpc/src/model/GetInstanceReportRequest.cc b/ehpc/src/model/GetInstanceReportRequest.cc new file mode 100644 index 000000000..cc1c43d73 --- /dev/null +++ b/ehpc/src/model/GetInstanceReportRequest.cc @@ -0,0 +1,84 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed 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. + */ + +#include + +using AlibabaCloud::EHPC::Model::GetInstanceReportRequest; + +GetInstanceReportRequest::GetInstanceReportRequest() : + RpcServiceRequest("ehpc", "2018-04-12", "GetInstanceReport") +{ + setMethod(HttpRequest::Method::Get); +} + +GetInstanceReportRequest::~GetInstanceReportRequest() +{} + +int GetInstanceReportRequest::getEndTime()const +{ + return endTime_; +} + +void GetInstanceReportRequest::setEndTime(int endTime) +{ + endTime_ = endTime; + setCoreParameter("EndTime", std::to_string(endTime)); +} + +std::string GetInstanceReportRequest::getFilterValue()const +{ + return filterValue_; +} + +void GetInstanceReportRequest::setFilterValue(const std::string& filterValue) +{ + filterValue_ = filterValue; + setCoreParameter("FilterValue", filterValue); +} + +std::string GetInstanceReportRequest::getClusterId()const +{ + return clusterId_; +} + +void GetInstanceReportRequest::setClusterId(const std::string& clusterId) +{ + clusterId_ = clusterId; + setCoreParameter("ClusterId", clusterId); +} + +int GetInstanceReportRequest::getStartTime()const +{ + return startTime_; +} + +void GetInstanceReportRequest::setStartTime(int startTime) +{ + startTime_ = startTime; + setCoreParameter("StartTime", std::to_string(startTime)); +} + +std::string GetInstanceReportRequest::getAccessKeyId()const +{ + return accessKeyId_; +} + +void GetInstanceReportRequest::setAccessKeyId(const std::string& accessKeyId) +{ + accessKeyId_ = accessKeyId; + setCoreParameter("AccessKeyId", accessKeyId); +} + diff --git a/ehpc/src/model/GetInstanceReportResult.cc b/ehpc/src/model/GetInstanceReportResult.cc new file mode 100644 index 000000000..5aa4989b3 --- /dev/null +++ b/ehpc/src/model/GetInstanceReportResult.cc @@ -0,0 +1,59 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed 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. + */ + +#include +#include + +using namespace AlibabaCloud::EHPC; +using namespace AlibabaCloud::EHPC::Model; + +GetInstanceReportResult::GetInstanceReportResult() : + ServiceResult() +{} + +GetInstanceReportResult::GetInstanceReportResult(const std::string &payload) : + ServiceResult() +{ + parse(payload); +} + +GetInstanceReportResult::~GetInstanceReportResult() +{} + +void GetInstanceReportResult::parse(const std::string &payload) +{ + Json::Reader reader; + Json::Value value; + reader.parse(payload, value); + setRequestId(value["RequestId"].asString()); + auto allData = value["Data"]["Data"]; + for (const auto &item : allData) + data_.push_back(item.asString()); + if(!value["Metrics"].isNull()) + metrics_ = value["Metrics"].asString(); + +} + +std::string GetInstanceReportResult::getMetrics()const +{ + return metrics_; +} + +std::vector GetInstanceReportResult::getData()const +{ + return data_; +} + diff --git a/ehpc/src/model/GetJobReportRequest.cc b/ehpc/src/model/GetJobReportRequest.cc new file mode 100644 index 000000000..c42df1bfc --- /dev/null +++ b/ehpc/src/model/GetJobReportRequest.cc @@ -0,0 +1,95 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed 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. + */ + +#include + +using AlibabaCloud::EHPC::Model::GetJobReportRequest; + +GetJobReportRequest::GetJobReportRequest() : + RpcServiceRequest("ehpc", "2018-04-12", "GetJobReport") +{ + setMethod(HttpRequest::Method::Get); +} + +GetJobReportRequest::~GetJobReportRequest() +{} + +std::string GetJobReportRequest::getReportType()const +{ + return reportType_; +} + +void GetJobReportRequest::setReportType(const std::string& reportType) +{ + reportType_ = reportType; + setCoreParameter("ReportType", reportType); +} + +int GetJobReportRequest::getEndTime()const +{ + return endTime_; +} + +void GetJobReportRequest::setEndTime(int endTime) +{ + endTime_ = endTime; + setCoreParameter("EndTime", std::to_string(endTime)); +} + +std::string GetJobReportRequest::getFilterValue()const +{ + return filterValue_; +} + +void GetJobReportRequest::setFilterValue(const std::string& filterValue) +{ + filterValue_ = filterValue; + setCoreParameter("FilterValue", filterValue); +} + +std::string GetJobReportRequest::getClusterId()const +{ + return clusterId_; +} + +void GetJobReportRequest::setClusterId(const std::string& clusterId) +{ + clusterId_ = clusterId; + setCoreParameter("ClusterId", clusterId); +} + +int GetJobReportRequest::getStartTime()const +{ + return startTime_; +} + +void GetJobReportRequest::setStartTime(int startTime) +{ + startTime_ = startTime; + setCoreParameter("StartTime", std::to_string(startTime)); +} + +std::string GetJobReportRequest::getAccessKeyId()const +{ + return accessKeyId_; +} + +void GetJobReportRequest::setAccessKeyId(const std::string& accessKeyId) +{ + accessKeyId_ = accessKeyId; + setCoreParameter("AccessKeyId", accessKeyId); +} + diff --git a/ehpc/src/model/GetJobReportResult.cc b/ehpc/src/model/GetJobReportResult.cc new file mode 100644 index 000000000..a89771f13 --- /dev/null +++ b/ehpc/src/model/GetJobReportResult.cc @@ -0,0 +1,59 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed 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. + */ + +#include +#include + +using namespace AlibabaCloud::EHPC; +using namespace AlibabaCloud::EHPC::Model; + +GetJobReportResult::GetJobReportResult() : + ServiceResult() +{} + +GetJobReportResult::GetJobReportResult(const std::string &payload) : + ServiceResult() +{ + parse(payload); +} + +GetJobReportResult::~GetJobReportResult() +{} + +void GetJobReportResult::parse(const std::string &payload) +{ + Json::Reader reader; + Json::Value value; + reader.parse(payload, value); + setRequestId(value["RequestId"].asString()); + auto allData = value["Data"]["Data"]; + for (const auto &item : allData) + data_.push_back(item.asString()); + if(!value["Metrics"].isNull()) + metrics_ = value["Metrics"].asString(); + +} + +std::string GetJobReportResult::getMetrics()const +{ + return metrics_; +} + +std::vector GetJobReportResult::getData()const +{ + return data_; +} + diff --git a/ehpc/src/model/GetTotalQueueReportRequest.cc b/ehpc/src/model/GetTotalQueueReportRequest.cc new file mode 100644 index 000000000..7f4f25be2 --- /dev/null +++ b/ehpc/src/model/GetTotalQueueReportRequest.cc @@ -0,0 +1,73 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed 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. + */ + +#include + +using AlibabaCloud::EHPC::Model::GetTotalQueueReportRequest; + +GetTotalQueueReportRequest::GetTotalQueueReportRequest() : + RpcServiceRequest("ehpc", "2018-04-12", "GetTotalQueueReport") +{ + setMethod(HttpRequest::Method::Get); +} + +GetTotalQueueReportRequest::~GetTotalQueueReportRequest() +{} + +int GetTotalQueueReportRequest::getEndTime()const +{ + return endTime_; +} + +void GetTotalQueueReportRequest::setEndTime(int endTime) +{ + endTime_ = endTime; + setCoreParameter("EndTime", std::to_string(endTime)); +} + +std::string GetTotalQueueReportRequest::getClusterId()const +{ + return clusterId_; +} + +void GetTotalQueueReportRequest::setClusterId(const std::string& clusterId) +{ + clusterId_ = clusterId; + setCoreParameter("ClusterId", clusterId); +} + +int GetTotalQueueReportRequest::getStartTime()const +{ + return startTime_; +} + +void GetTotalQueueReportRequest::setStartTime(int startTime) +{ + startTime_ = startTime; + setCoreParameter("StartTime", std::to_string(startTime)); +} + +std::string GetTotalQueueReportRequest::getAccessKeyId()const +{ + return accessKeyId_; +} + +void GetTotalQueueReportRequest::setAccessKeyId(const std::string& accessKeyId) +{ + accessKeyId_ = accessKeyId; + setCoreParameter("AccessKeyId", accessKeyId); +} + diff --git a/ehpc/src/model/GetTotalQueueReportResult.cc b/ehpc/src/model/GetTotalQueueReportResult.cc new file mode 100644 index 000000000..5f54437ed --- /dev/null +++ b/ehpc/src/model/GetTotalQueueReportResult.cc @@ -0,0 +1,59 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed 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. + */ + +#include +#include + +using namespace AlibabaCloud::EHPC; +using namespace AlibabaCloud::EHPC::Model; + +GetTotalQueueReportResult::GetTotalQueueReportResult() : + ServiceResult() +{} + +GetTotalQueueReportResult::GetTotalQueueReportResult(const std::string &payload) : + ServiceResult() +{ + parse(payload); +} + +GetTotalQueueReportResult::~GetTotalQueueReportResult() +{} + +void GetTotalQueueReportResult::parse(const std::string &payload) +{ + Json::Reader reader; + Json::Value value; + reader.parse(payload, value); + setRequestId(value["RequestId"].asString()); + auto allData = value["Data"]["Data"]; + for (const auto &item : allData) + data_.push_back(item.asString()); + if(!value["Metrics"].isNull()) + metrics_ = value["Metrics"].asString(); + +} + +std::string GetTotalQueueReportResult::getMetrics()const +{ + return metrics_; +} + +std::vector GetTotalQueueReportResult::getData()const +{ + return data_; +} + diff --git a/ehpc/src/model/GetTotalUserReportRequest.cc b/ehpc/src/model/GetTotalUserReportRequest.cc new file mode 100644 index 000000000..1995f6f93 --- /dev/null +++ b/ehpc/src/model/GetTotalUserReportRequest.cc @@ -0,0 +1,73 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed 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. + */ + +#include + +using AlibabaCloud::EHPC::Model::GetTotalUserReportRequest; + +GetTotalUserReportRequest::GetTotalUserReportRequest() : + RpcServiceRequest("ehpc", "2018-04-12", "GetTotalUserReport") +{ + setMethod(HttpRequest::Method::Get); +} + +GetTotalUserReportRequest::~GetTotalUserReportRequest() +{} + +int GetTotalUserReportRequest::getEndTime()const +{ + return endTime_; +} + +void GetTotalUserReportRequest::setEndTime(int endTime) +{ + endTime_ = endTime; + setCoreParameter("EndTime", std::to_string(endTime)); +} + +std::string GetTotalUserReportRequest::getClusterId()const +{ + return clusterId_; +} + +void GetTotalUserReportRequest::setClusterId(const std::string& clusterId) +{ + clusterId_ = clusterId; + setCoreParameter("ClusterId", clusterId); +} + +int GetTotalUserReportRequest::getStartTime()const +{ + return startTime_; +} + +void GetTotalUserReportRequest::setStartTime(int startTime) +{ + startTime_ = startTime; + setCoreParameter("StartTime", std::to_string(startTime)); +} + +std::string GetTotalUserReportRequest::getAccessKeyId()const +{ + return accessKeyId_; +} + +void GetTotalUserReportRequest::setAccessKeyId(const std::string& accessKeyId) +{ + accessKeyId_ = accessKeyId; + setCoreParameter("AccessKeyId", accessKeyId); +} + diff --git a/ehpc/src/model/GetTotalUserReportResult.cc b/ehpc/src/model/GetTotalUserReportResult.cc new file mode 100644 index 000000000..f439644e1 --- /dev/null +++ b/ehpc/src/model/GetTotalUserReportResult.cc @@ -0,0 +1,59 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed 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. + */ + +#include +#include + +using namespace AlibabaCloud::EHPC; +using namespace AlibabaCloud::EHPC::Model; + +GetTotalUserReportResult::GetTotalUserReportResult() : + ServiceResult() +{} + +GetTotalUserReportResult::GetTotalUserReportResult(const std::string &payload) : + ServiceResult() +{ + parse(payload); +} + +GetTotalUserReportResult::~GetTotalUserReportResult() +{} + +void GetTotalUserReportResult::parse(const std::string &payload) +{ + Json::Reader reader; + Json::Value value; + reader.parse(payload, value); + setRequestId(value["RequestId"].asString()); + auto allData = value["Data"]["Data"]; + for (const auto &item : allData) + data_.push_back(item.asString()); + if(!value["Metrics"].isNull()) + metrics_ = value["Metrics"].asString(); + +} + +std::string GetTotalUserReportResult::getMetrics()const +{ + return metrics_; +} + +std::vector GetTotalUserReportResult::getData()const +{ + return data_; +} + diff --git a/ehpc/src/model/GetVisualServiceStatusRequest.cc b/ehpc/src/model/GetVisualServiceStatusRequest.cc index eebfa7ffd..c4ab14206 100644 --- a/ehpc/src/model/GetVisualServiceStatusRequest.cc +++ b/ehpc/src/model/GetVisualServiceStatusRequest.cc @@ -20,7 +20,9 @@ using AlibabaCloud::EHPC::Model::GetVisualServiceStatusRequest; GetVisualServiceStatusRequest::GetVisualServiceStatusRequest() : RpcServiceRequest("ehpc", "2018-04-12", "GetVisualServiceStatus") -{} +{ + setMethod(HttpRequest::Method::Get); +} GetVisualServiceStatusRequest::~GetVisualServiceStatusRequest() {} diff --git a/ehpc/src/model/GetWorkbenchTokenRequest.cc b/ehpc/src/model/GetWorkbenchTokenRequest.cc new file mode 100644 index 000000000..cac9bd4fa --- /dev/null +++ b/ehpc/src/model/GetWorkbenchTokenRequest.cc @@ -0,0 +1,117 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed 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. + */ + +#include + +using AlibabaCloud::EHPC::Model::GetWorkbenchTokenRequest; + +GetWorkbenchTokenRequest::GetWorkbenchTokenRequest() : + RpcServiceRequest("ehpc", "2018-04-12", "GetWorkbenchToken") +{ + setMethod(HttpRequest::Method::Get); +} + +GetWorkbenchTokenRequest::~GetWorkbenchTokenRequest() +{} + +std::string GetWorkbenchTokenRequest::getClusterId()const +{ + return clusterId_; +} + +void GetWorkbenchTokenRequest::setClusterId(const std::string& clusterId) +{ + clusterId_ = clusterId; + setCoreParameter("ClusterId", clusterId); +} + +std::string GetWorkbenchTokenRequest::getAccessKeyId()const +{ + return accessKeyId_; +} + +void GetWorkbenchTokenRequest::setAccessKeyId(const std::string& accessKeyId) +{ + accessKeyId_ = accessKeyId; + setCoreParameter("AccessKeyId", accessKeyId); +} + +std::string GetWorkbenchTokenRequest::getUserPassword()const +{ + return userPassword_; +} + +void GetWorkbenchTokenRequest::setUserPassword(const std::string& userPassword) +{ + userPassword_ = userPassword; + setCoreParameter("UserPassword", userPassword); +} + +std::string GetWorkbenchTokenRequest::getInstanceId()const +{ + return instanceId_; +} + +void GetWorkbenchTokenRequest::setInstanceId(const std::string& instanceId) +{ + instanceId_ = instanceId; + setCoreParameter("InstanceId", instanceId); +} + +int GetWorkbenchTokenRequest::getPort()const +{ + return port_; +} + +void GetWorkbenchTokenRequest::setPort(int port) +{ + port_ = port; + setCoreParameter("Port", std::to_string(port)); +} + +std::string GetWorkbenchTokenRequest::getAccountSessionTicket()const +{ + return accountSessionTicket_; +} + +void GetWorkbenchTokenRequest::setAccountSessionTicket(const std::string& accountSessionTicket) +{ + accountSessionTicket_ = accountSessionTicket; + setCoreParameter("AccountSessionTicket", accountSessionTicket); +} + +std::string GetWorkbenchTokenRequest::getAccountUid()const +{ + return accountUid_; +} + +void GetWorkbenchTokenRequest::setAccountUid(const std::string& accountUid) +{ + accountUid_ = accountUid; + setCoreParameter("AccountUid", accountUid); +} + +std::string GetWorkbenchTokenRequest::getUserName()const +{ + return userName_; +} + +void GetWorkbenchTokenRequest::setUserName(const std::string& userName) +{ + userName_ = userName; + setCoreParameter("UserName", userName); +} + diff --git a/ehpc/src/model/GetWorkbenchTokenResult.cc b/ehpc/src/model/GetWorkbenchTokenResult.cc new file mode 100644 index 000000000..3c7e16153 --- /dev/null +++ b/ehpc/src/model/GetWorkbenchTokenResult.cc @@ -0,0 +1,63 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed 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. + */ + +#include +#include + +using namespace AlibabaCloud::EHPC; +using namespace AlibabaCloud::EHPC::Model; + +GetWorkbenchTokenResult::GetWorkbenchTokenResult() : + ServiceResult() +{} + +GetWorkbenchTokenResult::GetWorkbenchTokenResult(const std::string &payload) : + ServiceResult() +{ + parse(payload); +} + +GetWorkbenchTokenResult::~GetWorkbenchTokenResult() +{} + +void GetWorkbenchTokenResult::parse(const std::string &payload) +{ + Json::Reader reader; + Json::Value value; + reader.parse(payload, value); + setRequestId(value["RequestId"].asString()); + auto rootNode = value["root"]; + auto instanceLoginViewNode = rootNode["instanceLoginView"]; + if(!instanceLoginViewNode["viewName"].isNull()) + root_.instanceLoginView.viewName = instanceLoginViewNode["viewName"].asString(); + if(!instanceLoginViewNode["defaultViewUrl"].isNull()) + root_.instanceLoginView.defaultViewUrl = instanceLoginViewNode["defaultViewUrl"].asString(); + if(!instanceLoginViewNode["baseViewUrl"].isNull()) + root_.instanceLoginView.baseViewUrl = instanceLoginViewNode["baseViewUrl"].asString(); + if(!instanceLoginViewNode["terminalViewUrl"].isNull()) + root_.instanceLoginView.terminalViewUrl = instanceLoginViewNode["terminalViewUrl"].asString(); + if(!instanceLoginViewNode["fileTreeViewUrl"].isNull()) + root_.instanceLoginView.fileTreeViewUrl = instanceLoginViewNode["fileTreeViewUrl"].asString(); + if(!instanceLoginViewNode["rdpViewUrl"].isNull()) + root_.instanceLoginView.rdpViewUrl = instanceLoginViewNode["rdpViewUrl"].asString(); + +} + +GetWorkbenchTokenResult::Root GetWorkbenchTokenResult::getRoot()const +{ + return root_; +} + diff --git a/ehpc/src/model/InstallNFSClientRequest.cc b/ehpc/src/model/InstallNFSClientRequest.cc index eec1c546f..5858bc3b1 100644 --- a/ehpc/src/model/InstallNFSClientRequest.cc +++ b/ehpc/src/model/InstallNFSClientRequest.cc @@ -20,7 +20,9 @@ using AlibabaCloud::EHPC::Model::InstallNFSClientRequest; InstallNFSClientRequest::InstallNFSClientRequest() : RpcServiceRequest("ehpc", "2018-04-12", "InstallNFSClient") -{} +{ + setMethod(HttpRequest::Method::Get); +} InstallNFSClientRequest::~InstallNFSClientRequest() {} diff --git a/ehpc/src/model/InstallSoftwareRequest.cc b/ehpc/src/model/InstallSoftwareRequest.cc index ea50d5e15..7343151c0 100644 --- a/ehpc/src/model/InstallSoftwareRequest.cc +++ b/ehpc/src/model/InstallSoftwareRequest.cc @@ -20,7 +20,9 @@ using AlibabaCloud::EHPC::Model::InstallSoftwareRequest; InstallSoftwareRequest::InstallSoftwareRequest() : RpcServiceRequest("ehpc", "2018-04-12", "InstallSoftware") -{} +{ + setMethod(HttpRequest::Method::Get); +} InstallSoftwareRequest::~InstallSoftwareRequest() {} diff --git a/ehpc/src/model/InvokeShellCommandRequest.cc b/ehpc/src/model/InvokeShellCommandRequest.cc index df3543945..49beac649 100644 --- a/ehpc/src/model/InvokeShellCommandRequest.cc +++ b/ehpc/src/model/InvokeShellCommandRequest.cc @@ -20,7 +20,9 @@ using AlibabaCloud::EHPC::Model::InvokeShellCommandRequest; InvokeShellCommandRequest::InvokeShellCommandRequest() : RpcServiceRequest("ehpc", "2018-04-12", "InvokeShellCommand") -{} +{ + setMethod(HttpRequest::Method::Get); +} InvokeShellCommandRequest::~InvokeShellCommandRequest() {} @@ -33,11 +35,10 @@ std::vector InvokeShellCommandRequest::getI void InvokeShellCommandRequest::setInstance(const std::vector& instance) { instance_ = instance; - int i = 0; - for(int i = 0; i!= instance.size(); i++) { - auto obj = instance.at(i); - std::string str ="Instance."+ std::to_string(i); - setCoreParameter(str + ".Id", obj.id); + for(int dep1 = 0; dep1!= instance.size(); dep1++) { + auto instanceObj = instance.at(dep1); + std::string instanceObjStr = "Instance." + std::to_string(dep1); + setCoreParameter(instanceObjStr + ".Id", instanceObj.id); } } diff --git a/ehpc/src/model/ListAccountMappingRequest.cc b/ehpc/src/model/ListAccountMappingRequest.cc new file mode 100644 index 000000000..d146319fb --- /dev/null +++ b/ehpc/src/model/ListAccountMappingRequest.cc @@ -0,0 +1,51 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed 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. + */ + +#include + +using AlibabaCloud::EHPC::Model::ListAccountMappingRequest; + +ListAccountMappingRequest::ListAccountMappingRequest() : + RpcServiceRequest("ehpc", "2018-04-12", "ListAccountMapping") +{ + setMethod(HttpRequest::Method::Get); +} + +ListAccountMappingRequest::~ListAccountMappingRequest() +{} + +std::string ListAccountMappingRequest::getClusterId()const +{ + return clusterId_; +} + +void ListAccountMappingRequest::setClusterId(const std::string& clusterId) +{ + clusterId_ = clusterId; + setCoreParameter("ClusterId", clusterId); +} + +std::string ListAccountMappingRequest::getAccessKeyId()const +{ + return accessKeyId_; +} + +void ListAccountMappingRequest::setAccessKeyId(const std::string& accessKeyId) +{ + accessKeyId_ = accessKeyId; + setCoreParameter("AccessKeyId", accessKeyId); +} + diff --git a/ehpc/src/model/ListAccountMappingResult.cc b/ehpc/src/model/ListAccountMappingResult.cc new file mode 100644 index 000000000..456c020d3 --- /dev/null +++ b/ehpc/src/model/ListAccountMappingResult.cc @@ -0,0 +1,61 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed 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. + */ + +#include +#include + +using namespace AlibabaCloud::EHPC; +using namespace AlibabaCloud::EHPC::Model; + +ListAccountMappingResult::ListAccountMappingResult() : + ServiceResult() +{} + +ListAccountMappingResult::ListAccountMappingResult(const std::string &payload) : + ServiceResult() +{ + parse(payload); +} + +ListAccountMappingResult::~ListAccountMappingResult() +{} + +void ListAccountMappingResult::parse(const std::string &payload) +{ + Json::Reader reader; + Json::Value value; + reader.parse(payload, value); + setRequestId(value["RequestId"].asString()); + auto allUserMappingsNode = value["UserMappings"]["UserMapping"]; + for (auto valueUserMappingsUserMapping : allUserMappingsNode) + { + UserMapping userMappingsObject; + if(!valueUserMappingsUserMapping["UserName"].isNull()) + userMappingsObject.userName = valueUserMappingsUserMapping["UserName"].asString(); + if(!valueUserMappingsUserMapping["AccountId"].isNull()) + userMappingsObject.accountId = valueUserMappingsUserMapping["AccountId"].asString(); + if(!valueUserMappingsUserMapping["AccountName"].isNull()) + userMappingsObject.accountName = valueUserMappingsUserMapping["AccountName"].asString(); + userMappings_.push_back(userMappingsObject); + } + +} + +std::vector ListAccountMappingResult::getUserMappings()const +{ + return userMappings_; +} + diff --git a/ehpc/src/model/ListAvailableEcsTypesRequest.cc b/ehpc/src/model/ListAvailableEcsTypesRequest.cc index 459c9606c..65b5b99e9 100644 --- a/ehpc/src/model/ListAvailableEcsTypesRequest.cc +++ b/ehpc/src/model/ListAvailableEcsTypesRequest.cc @@ -20,7 +20,9 @@ using AlibabaCloud::EHPC::Model::ListAvailableEcsTypesRequest; ListAvailableEcsTypesRequest::ListAvailableEcsTypesRequest() : RpcServiceRequest("ehpc", "2018-04-12", "ListAvailableEcsTypes") -{} +{ + setMethod(HttpRequest::Method::Get); +} ListAvailableEcsTypesRequest::~ListAvailableEcsTypesRequest() {} diff --git a/ehpc/src/model/ListAvailableFileSystemTypesRequest.cc b/ehpc/src/model/ListAvailableFileSystemTypesRequest.cc index f81fb3367..6d6ca695d 100644 --- a/ehpc/src/model/ListAvailableFileSystemTypesRequest.cc +++ b/ehpc/src/model/ListAvailableFileSystemTypesRequest.cc @@ -20,7 +20,9 @@ using AlibabaCloud::EHPC::Model::ListAvailableFileSystemTypesRequest; ListAvailableFileSystemTypesRequest::ListAvailableFileSystemTypesRequest() : RpcServiceRequest("ehpc", "2018-04-12", "ListAvailableFileSystemTypes") -{} +{ + setMethod(HttpRequest::Method::Get); +} ListAvailableFileSystemTypesRequest::~ListAvailableFileSystemTypesRequest() {} diff --git a/ehpc/src/model/ListCloudMetricProfilingsRequest.cc b/ehpc/src/model/ListCloudMetricProfilingsRequest.cc index 49d92ecdf..e39287838 100644 --- a/ehpc/src/model/ListCloudMetricProfilingsRequest.cc +++ b/ehpc/src/model/ListCloudMetricProfilingsRequest.cc @@ -20,7 +20,9 @@ using AlibabaCloud::EHPC::Model::ListCloudMetricProfilingsRequest; ListCloudMetricProfilingsRequest::ListCloudMetricProfilingsRequest() : RpcServiceRequest("ehpc", "2018-04-12", "ListCloudMetricProfilings") -{} +{ + setMethod(HttpRequest::Method::Get); +} ListCloudMetricProfilingsRequest::~ListCloudMetricProfilingsRequest() {} diff --git a/ehpc/src/model/ListClusterLogsRequest.cc b/ehpc/src/model/ListClusterLogsRequest.cc index d12789a81..681d21047 100644 --- a/ehpc/src/model/ListClusterLogsRequest.cc +++ b/ehpc/src/model/ListClusterLogsRequest.cc @@ -20,7 +20,9 @@ using AlibabaCloud::EHPC::Model::ListClusterLogsRequest; ListClusterLogsRequest::ListClusterLogsRequest() : RpcServiceRequest("ehpc", "2018-04-12", "ListClusterLogs") -{} +{ + setMethod(HttpRequest::Method::Get); +} ListClusterLogsRequest::~ListClusterLogsRequest() {} diff --git a/ehpc/src/model/ListClustersMetaRequest.cc b/ehpc/src/model/ListClustersMetaRequest.cc index f4fbe3a54..063467b5d 100644 --- a/ehpc/src/model/ListClustersMetaRequest.cc +++ b/ehpc/src/model/ListClustersMetaRequest.cc @@ -20,7 +20,9 @@ using AlibabaCloud::EHPC::Model::ListClustersMetaRequest; ListClustersMetaRequest::ListClustersMetaRequest() : RpcServiceRequest("ehpc", "2018-04-12", "ListClustersMeta") -{} +{ + setMethod(HttpRequest::Method::Get); +} ListClustersMetaRequest::~ListClustersMetaRequest() {} diff --git a/ehpc/src/model/ListClustersRequest.cc b/ehpc/src/model/ListClustersRequest.cc index 6c49e66b2..8f9876426 100644 --- a/ehpc/src/model/ListClustersRequest.cc +++ b/ehpc/src/model/ListClustersRequest.cc @@ -20,7 +20,9 @@ using AlibabaCloud::EHPC::Model::ListClustersRequest; ListClustersRequest::ListClustersRequest() : RpcServiceRequest("ehpc", "2018-04-12", "ListClusters") -{} +{ + setMethod(HttpRequest::Method::Get); +} ListClustersRequest::~ListClustersRequest() {} diff --git a/ehpc/src/model/ListCommandsRequest.cc b/ehpc/src/model/ListCommandsRequest.cc index 86fc62b05..90d603cb3 100644 --- a/ehpc/src/model/ListCommandsRequest.cc +++ b/ehpc/src/model/ListCommandsRequest.cc @@ -20,7 +20,9 @@ using AlibabaCloud::EHPC::Model::ListCommandsRequest; ListCommandsRequest::ListCommandsRequest() : RpcServiceRequest("ehpc", "2018-04-12", "ListCommands") -{} +{ + setMethod(HttpRequest::Method::Get); +} ListCommandsRequest::~ListCommandsRequest() {} diff --git a/ehpc/src/model/ListContainerAppsRequest.cc b/ehpc/src/model/ListContainerAppsRequest.cc index 50623327d..348ec1109 100644 --- a/ehpc/src/model/ListContainerAppsRequest.cc +++ b/ehpc/src/model/ListContainerAppsRequest.cc @@ -20,7 +20,9 @@ using AlibabaCloud::EHPC::Model::ListContainerAppsRequest; ListContainerAppsRequest::ListContainerAppsRequest() : RpcServiceRequest("ehpc", "2018-04-12", "ListContainerApps") -{} +{ + setMethod(HttpRequest::Method::Get); +} ListContainerAppsRequest::~ListContainerAppsRequest() {} diff --git a/ehpc/src/model/ListContainerImagesRequest.cc b/ehpc/src/model/ListContainerImagesRequest.cc index c90329e07..a0faf627d 100644 --- a/ehpc/src/model/ListContainerImagesRequest.cc +++ b/ehpc/src/model/ListContainerImagesRequest.cc @@ -20,7 +20,9 @@ using AlibabaCloud::EHPC::Model::ListContainerImagesRequest; ListContainerImagesRequest::ListContainerImagesRequest() : RpcServiceRequest("ehpc", "2018-04-12", "ListContainerImages") -{} +{ + setMethod(HttpRequest::Method::Get); +} ListContainerImagesRequest::~ListContainerImagesRequest() {} diff --git a/ehpc/src/model/ListCpfsFileSystemsRequest.cc b/ehpc/src/model/ListCpfsFileSystemsRequest.cc index 5ddf0e566..53cc87666 100644 --- a/ehpc/src/model/ListCpfsFileSystemsRequest.cc +++ b/ehpc/src/model/ListCpfsFileSystemsRequest.cc @@ -20,7 +20,9 @@ using AlibabaCloud::EHPC::Model::ListCpfsFileSystemsRequest; ListCpfsFileSystemsRequest::ListCpfsFileSystemsRequest() : RpcServiceRequest("ehpc", "2018-04-12", "ListCpfsFileSystems") -{} +{ + setMethod(HttpRequest::Method::Get); +} ListCpfsFileSystemsRequest::~ListCpfsFileSystemsRequest() {} diff --git a/ehpc/src/model/ListCurrentClientVersionRequest.cc b/ehpc/src/model/ListCurrentClientVersionRequest.cc index e4dad1e63..390dbea25 100644 --- a/ehpc/src/model/ListCurrentClientVersionRequest.cc +++ b/ehpc/src/model/ListCurrentClientVersionRequest.cc @@ -20,7 +20,9 @@ using AlibabaCloud::EHPC::Model::ListCurrentClientVersionRequest; ListCurrentClientVersionRequest::ListCurrentClientVersionRequest() : RpcServiceRequest("ehpc", "2018-04-12", "ListCurrentClientVersion") -{} +{ + setMethod(HttpRequest::Method::Get); +} ListCurrentClientVersionRequest::~ListCurrentClientVersionRequest() {} diff --git a/ehpc/src/model/ListCustomImagesRequest.cc b/ehpc/src/model/ListCustomImagesRequest.cc index b65cec186..2700261da 100644 --- a/ehpc/src/model/ListCustomImagesRequest.cc +++ b/ehpc/src/model/ListCustomImagesRequest.cc @@ -20,7 +20,9 @@ using AlibabaCloud::EHPC::Model::ListCustomImagesRequest; ListCustomImagesRequest::ListCustomImagesRequest() : RpcServiceRequest("ehpc", "2018-04-12", "ListCustomImages") -{} +{ + setMethod(HttpRequest::Method::Get); +} ListCustomImagesRequest::~ListCustomImagesRequest() {} diff --git a/ehpc/src/model/ListFileSystemWithMountTargetsRequest.cc b/ehpc/src/model/ListFileSystemWithMountTargetsRequest.cc index 2fa6cf68c..ef3393d5c 100644 --- a/ehpc/src/model/ListFileSystemWithMountTargetsRequest.cc +++ b/ehpc/src/model/ListFileSystemWithMountTargetsRequest.cc @@ -20,7 +20,9 @@ using AlibabaCloud::EHPC::Model::ListFileSystemWithMountTargetsRequest; ListFileSystemWithMountTargetsRequest::ListFileSystemWithMountTargetsRequest() : RpcServiceRequest("ehpc", "2018-04-12", "ListFileSystemWithMountTargets") -{} +{ + setMethod(HttpRequest::Method::Get); +} ListFileSystemWithMountTargetsRequest::~ListFileSystemWithMountTargetsRequest() {} diff --git a/ehpc/src/model/ListFileSystemWithMountTargetsResult.cc b/ehpc/src/model/ListFileSystemWithMountTargetsResult.cc index 00f1828f3..a3985b68c 100644 --- a/ehpc/src/model/ListFileSystemWithMountTargetsResult.cc +++ b/ehpc/src/model/ListFileSystemWithMountTargetsResult.cc @@ -47,6 +47,8 @@ void ListFileSystemWithMountTargetsResult::parse(const std::string &payload) fileSystemListObject.regionId = valueFileSystemListFileSystems["RegionId"].asString(); if(!valueFileSystemListFileSystems["FileSystemId"].isNull()) fileSystemListObject.fileSystemId = valueFileSystemListFileSystems["FileSystemId"].asString(); + if(!valueFileSystemListFileSystems["FileSystemType"].isNull()) + fileSystemListObject.fileSystemType = valueFileSystemListFileSystems["FileSystemType"].asString(); if(!valueFileSystemListFileSystems["ProtocolType"].isNull()) fileSystemListObject.protocolType = valueFileSystemListFileSystems["ProtocolType"].asString(); if(!valueFileSystemListFileSystems["CreateTime"].isNull()) @@ -56,7 +58,15 @@ void ListFileSystemWithMountTargetsResult::parse(const std::string &payload) if(!valueFileSystemListFileSystems["StorageType"].isNull()) fileSystemListObject.storageType = valueFileSystemListFileSystems["StorageType"].asString(); if(!valueFileSystemListFileSystems["MeteredSize"].isNull()) - fileSystemListObject.meteredSize = valueFileSystemListFileSystems["MeteredSize"].asString(); + fileSystemListObject.meteredSize = std::stoi(valueFileSystemListFileSystems["MeteredSize"].asString()); + if(!valueFileSystemListFileSystems["Capacity"].isNull()) + fileSystemListObject.capacity = std::stoi(valueFileSystemListFileSystems["Capacity"].asString()); + if(!valueFileSystemListFileSystems["EncryptType"].isNull()) + fileSystemListObject.encryptType = std::stoi(valueFileSystemListFileSystems["EncryptType"].asString()); + if(!valueFileSystemListFileSystems["BandWidth"].isNull()) + fileSystemListObject.bandWidth = std::stoi(valueFileSystemListFileSystems["BandWidth"].asString()); + if(!valueFileSystemListFileSystems["Status"].isNull()) + fileSystemListObject.status = valueFileSystemListFileSystems["Status"].asString(); auto allPackageListNode = allFileSystemListNode["PackageList"]["Packages"]; for (auto allFileSystemListNodePackageListPackages : allPackageListNode) { diff --git a/ehpc/src/model/ListImagesRequest.cc b/ehpc/src/model/ListImagesRequest.cc index f417dc17d..4c73ccef1 100644 --- a/ehpc/src/model/ListImagesRequest.cc +++ b/ehpc/src/model/ListImagesRequest.cc @@ -20,7 +20,9 @@ using AlibabaCloud::EHPC::Model::ListImagesRequest; ListImagesRequest::ListImagesRequest() : RpcServiceRequest("ehpc", "2018-04-12", "ListImages") -{} +{ + setMethod(HttpRequest::Method::Get); +} ListImagesRequest::~ListImagesRequest() {} diff --git a/ehpc/src/model/ListInstalledSoftwareRequest.cc b/ehpc/src/model/ListInstalledSoftwareRequest.cc index 0e4c76061..64a917949 100644 --- a/ehpc/src/model/ListInstalledSoftwareRequest.cc +++ b/ehpc/src/model/ListInstalledSoftwareRequest.cc @@ -20,7 +20,9 @@ using AlibabaCloud::EHPC::Model::ListInstalledSoftwareRequest; ListInstalledSoftwareRequest::ListInstalledSoftwareRequest() : RpcServiceRequest("ehpc", "2018-04-12", "ListInstalledSoftware") -{} +{ + setMethod(HttpRequest::Method::Get); +} ListInstalledSoftwareRequest::~ListInstalledSoftwareRequest() {} diff --git a/ehpc/src/model/ListInvocationResultsRequest.cc b/ehpc/src/model/ListInvocationResultsRequest.cc index 4c24c2ba4..1cb3e9345 100644 --- a/ehpc/src/model/ListInvocationResultsRequest.cc +++ b/ehpc/src/model/ListInvocationResultsRequest.cc @@ -20,7 +20,9 @@ using AlibabaCloud::EHPC::Model::ListInvocationResultsRequest; ListInvocationResultsRequest::ListInvocationResultsRequest() : RpcServiceRequest("ehpc", "2018-04-12", "ListInvocationResults") -{} +{ + setMethod(HttpRequest::Method::Get); +} ListInvocationResultsRequest::~ListInvocationResultsRequest() {} @@ -33,11 +35,10 @@ std::vector ListInvocationResultsRequest void ListInvocationResultsRequest::setInstance(const std::vector& instance) { instance_ = instance; - int i = 0; - for(int i = 0; i!= instance.size(); i++) { - auto obj = instance.at(i); - std::string str ="Instance."+ std::to_string(i); - setCoreParameter(str + ".Id", obj.id); + for(int dep1 = 0; dep1!= instance.size(); dep1++) { + auto instanceObj = instance.at(dep1); + std::string instanceObjStr = "Instance." + std::to_string(dep1); + setCoreParameter(instanceObjStr + ".Id", instanceObj.id); } } diff --git a/ehpc/src/model/ListInvocationStatusRequest.cc b/ehpc/src/model/ListInvocationStatusRequest.cc index 54a0c7b64..97ae35c4e 100644 --- a/ehpc/src/model/ListInvocationStatusRequest.cc +++ b/ehpc/src/model/ListInvocationStatusRequest.cc @@ -20,7 +20,9 @@ using AlibabaCloud::EHPC::Model::ListInvocationStatusRequest; ListInvocationStatusRequest::ListInvocationStatusRequest() : RpcServiceRequest("ehpc", "2018-04-12", "ListInvocationStatus") -{} +{ + setMethod(HttpRequest::Method::Get); +} ListInvocationStatusRequest::~ListInvocationStatusRequest() {} diff --git a/ehpc/src/model/ListJobTemplatesRequest.cc b/ehpc/src/model/ListJobTemplatesRequest.cc index 3755511e1..3f71d7aa7 100644 --- a/ehpc/src/model/ListJobTemplatesRequest.cc +++ b/ehpc/src/model/ListJobTemplatesRequest.cc @@ -20,7 +20,9 @@ using AlibabaCloud::EHPC::Model::ListJobTemplatesRequest; ListJobTemplatesRequest::ListJobTemplatesRequest() : RpcServiceRequest("ehpc", "2018-04-12", "ListJobTemplates") -{} +{ + setMethod(HttpRequest::Method::Get); +} ListJobTemplatesRequest::~ListJobTemplatesRequest() {} diff --git a/ehpc/src/model/ListJobsRequest.cc b/ehpc/src/model/ListJobsRequest.cc index 7821dcbfb..afc5831ac 100644 --- a/ehpc/src/model/ListJobsRequest.cc +++ b/ehpc/src/model/ListJobsRequest.cc @@ -20,7 +20,9 @@ using AlibabaCloud::EHPC::Model::ListJobsRequest; ListJobsRequest::ListJobsRequest() : RpcServiceRequest("ehpc", "2018-04-12", "ListJobs") -{} +{ + setMethod(HttpRequest::Method::Get); +} ListJobsRequest::~ListJobsRequest() {} diff --git a/ehpc/src/model/ListNodesByQueueRequest.cc b/ehpc/src/model/ListNodesByQueueRequest.cc index 80f1658a3..8c2ca43ba 100644 --- a/ehpc/src/model/ListNodesByQueueRequest.cc +++ b/ehpc/src/model/ListNodesByQueueRequest.cc @@ -20,7 +20,9 @@ using AlibabaCloud::EHPC::Model::ListNodesByQueueRequest; ListNodesByQueueRequest::ListNodesByQueueRequest() : RpcServiceRequest("ehpc", "2018-04-12", "ListNodesByQueue") -{} +{ + setMethod(HttpRequest::Method::Get); +} ListNodesByQueueRequest::~ListNodesByQueueRequest() {} diff --git a/ehpc/src/model/ListNodesNoPagingRequest.cc b/ehpc/src/model/ListNodesNoPagingRequest.cc index 01f8c0048..385c50fca 100644 --- a/ehpc/src/model/ListNodesNoPagingRequest.cc +++ b/ehpc/src/model/ListNodesNoPagingRequest.cc @@ -20,7 +20,9 @@ using AlibabaCloud::EHPC::Model::ListNodesNoPagingRequest; ListNodesNoPagingRequest::ListNodesNoPagingRequest() : RpcServiceRequest("ehpc", "2018-04-12", "ListNodesNoPaging") -{} +{ + setMethod(HttpRequest::Method::Get); +} ListNodesNoPagingRequest::~ListNodesNoPagingRequest() {} diff --git a/ehpc/src/model/ListNodesRequest.cc b/ehpc/src/model/ListNodesRequest.cc index 7e388a39e..9df9a90fd 100644 --- a/ehpc/src/model/ListNodesRequest.cc +++ b/ehpc/src/model/ListNodesRequest.cc @@ -20,7 +20,9 @@ using AlibabaCloud::EHPC::Model::ListNodesRequest; ListNodesRequest::ListNodesRequest() : RpcServiceRequest("ehpc", "2018-04-12", "ListNodes") -{} +{ + setMethod(HttpRequest::Method::Get); +} ListNodesRequest::~ListNodesRequest() {} diff --git a/ehpc/src/model/ListPreferredEcsTypesRequest.cc b/ehpc/src/model/ListPreferredEcsTypesRequest.cc index cb22b9c98..918330ebc 100644 --- a/ehpc/src/model/ListPreferredEcsTypesRequest.cc +++ b/ehpc/src/model/ListPreferredEcsTypesRequest.cc @@ -20,7 +20,9 @@ using AlibabaCloud::EHPC::Model::ListPreferredEcsTypesRequest; ListPreferredEcsTypesRequest::ListPreferredEcsTypesRequest() : RpcServiceRequest("ehpc", "2018-04-12", "ListPreferredEcsTypes") -{} +{ + setMethod(HttpRequest::Method::Get); +} ListPreferredEcsTypesRequest::~ListPreferredEcsTypesRequest() {} diff --git a/ehpc/src/model/ListQueuesRequest.cc b/ehpc/src/model/ListQueuesRequest.cc index b3fb8e438..5facf6eac 100644 --- a/ehpc/src/model/ListQueuesRequest.cc +++ b/ehpc/src/model/ListQueuesRequest.cc @@ -20,7 +20,9 @@ using AlibabaCloud::EHPC::Model::ListQueuesRequest; ListQueuesRequest::ListQueuesRequest() : RpcServiceRequest("ehpc", "2018-04-12", "ListQueues") -{} +{ + setMethod(HttpRequest::Method::Get); +} ListQueuesRequest::~ListQueuesRequest() {} diff --git a/ehpc/src/model/ListRegionsRequest.cc b/ehpc/src/model/ListRegionsRequest.cc index 68fe2861a..359d3b895 100644 --- a/ehpc/src/model/ListRegionsRequest.cc +++ b/ehpc/src/model/ListRegionsRequest.cc @@ -20,7 +20,9 @@ using AlibabaCloud::EHPC::Model::ListRegionsRequest; ListRegionsRequest::ListRegionsRequest() : RpcServiceRequest("ehpc", "2018-04-12", "ListRegions") -{} +{ + setMethod(HttpRequest::Method::Get); +} ListRegionsRequest::~ListRegionsRequest() {} diff --git a/ehpc/src/model/ListSoftwaresRequest.cc b/ehpc/src/model/ListSoftwaresRequest.cc index 8b7f643ed..bf6aca2d2 100644 --- a/ehpc/src/model/ListSoftwaresRequest.cc +++ b/ehpc/src/model/ListSoftwaresRequest.cc @@ -20,7 +20,9 @@ using AlibabaCloud::EHPC::Model::ListSoftwaresRequest; ListSoftwaresRequest::ListSoftwaresRequest() : RpcServiceRequest("ehpc", "2018-04-12", "ListSoftwares") -{} +{ + setMethod(HttpRequest::Method::Get); +} ListSoftwaresRequest::~ListSoftwaresRequest() {} diff --git a/ehpc/src/model/ListUsersRequest.cc b/ehpc/src/model/ListUsersRequest.cc index e01b71d9a..36f4f0627 100644 --- a/ehpc/src/model/ListUsersRequest.cc +++ b/ehpc/src/model/ListUsersRequest.cc @@ -20,7 +20,9 @@ using AlibabaCloud::EHPC::Model::ListUsersRequest; ListUsersRequest::ListUsersRequest() : RpcServiceRequest("ehpc", "2018-04-12", "ListUsers") -{} +{ + setMethod(HttpRequest::Method::Get); +} ListUsersRequest::~ListUsersRequest() {} diff --git a/ehpc/src/model/ListVolumesRequest.cc b/ehpc/src/model/ListVolumesRequest.cc index ade9ac811..17342f3d8 100644 --- a/ehpc/src/model/ListVolumesRequest.cc +++ b/ehpc/src/model/ListVolumesRequest.cc @@ -20,7 +20,9 @@ using AlibabaCloud::EHPC::Model::ListVolumesRequest; ListVolumesRequest::ListVolumesRequest() : RpcServiceRequest("ehpc", "2018-04-12", "ListVolumes") -{} +{ + setMethod(HttpRequest::Method::Get); +} ListVolumesRequest::~ListVolumesRequest() {} diff --git a/ehpc/src/model/ModifyClusterAttributesRequest.cc b/ehpc/src/model/ModifyClusterAttributesRequest.cc index 3216cafdf..336b2355f 100644 --- a/ehpc/src/model/ModifyClusterAttributesRequest.cc +++ b/ehpc/src/model/ModifyClusterAttributesRequest.cc @@ -20,7 +20,9 @@ using AlibabaCloud::EHPC::Model::ModifyClusterAttributesRequest; ModifyClusterAttributesRequest::ModifyClusterAttributesRequest() : RpcServiceRequest("ehpc", "2018-04-12", "ModifyClusterAttributes") -{} +{ + setMethod(HttpRequest::Method::Get); +} ModifyClusterAttributesRequest::~ModifyClusterAttributesRequest() {} diff --git a/ehpc/src/model/ModifyContainerAppAttributesRequest.cc b/ehpc/src/model/ModifyContainerAppAttributesRequest.cc index 36f3def78..c387a57b1 100644 --- a/ehpc/src/model/ModifyContainerAppAttributesRequest.cc +++ b/ehpc/src/model/ModifyContainerAppAttributesRequest.cc @@ -20,7 +20,9 @@ using AlibabaCloud::EHPC::Model::ModifyContainerAppAttributesRequest; ModifyContainerAppAttributesRequest::ModifyContainerAppAttributesRequest() : RpcServiceRequest("ehpc", "2018-04-12", "ModifyContainerAppAttributes") -{} +{ + setMethod(HttpRequest::Method::Get); +} ModifyContainerAppAttributesRequest::~ModifyContainerAppAttributesRequest() {} diff --git a/ehpc/src/model/ModifyImageGatewayConfigRequest.cc b/ehpc/src/model/ModifyImageGatewayConfigRequest.cc index e7227c2f1..33571ff32 100644 --- a/ehpc/src/model/ModifyImageGatewayConfigRequest.cc +++ b/ehpc/src/model/ModifyImageGatewayConfigRequest.cc @@ -20,7 +20,9 @@ using AlibabaCloud::EHPC::Model::ModifyImageGatewayConfigRequest; ModifyImageGatewayConfigRequest::ModifyImageGatewayConfigRequest() : RpcServiceRequest("ehpc", "2018-04-12", "ModifyImageGatewayConfig") -{} +{ + setMethod(HttpRequest::Method::Get); +} ModifyImageGatewayConfigRequest::~ModifyImageGatewayConfigRequest() {} @@ -33,13 +35,12 @@ std::vector ModifyImageGatewayConfigReque void ModifyImageGatewayConfigRequest::setRepo(const std::vector& repo) { repo_ = repo; - int i = 0; - for(int i = 0; i!= repo.size(); i++) { - auto obj = repo.at(i); - std::string str ="Repo."+ std::to_string(i); - setCoreParameter(str + ".Auth", obj.auth); - setCoreParameter(str + ".Location", obj.location); - setCoreParameter(str + ".URL", obj.uRL); + for(int dep1 = 0; dep1!= repo.size(); dep1++) { + auto repoObj = repo.at(dep1); + std::string repoObjStr = "Repo." + std::to_string(dep1); + setCoreParameter(repoObjStr + ".Auth", repoObj.auth); + setCoreParameter(repoObjStr + ".Location", repoObj.location); + setCoreParameter(repoObjStr + ".URL", repoObj.uRL); } } diff --git a/ehpc/src/model/ModifyUserGroupsRequest.cc b/ehpc/src/model/ModifyUserGroupsRequest.cc index 94e04abbe..baeedfc42 100644 --- a/ehpc/src/model/ModifyUserGroupsRequest.cc +++ b/ehpc/src/model/ModifyUserGroupsRequest.cc @@ -20,7 +20,9 @@ using AlibabaCloud::EHPC::Model::ModifyUserGroupsRequest; ModifyUserGroupsRequest::ModifyUserGroupsRequest() : RpcServiceRequest("ehpc", "2018-04-12", "ModifyUserGroups") -{} +{ + setMethod(HttpRequest::Method::Get); +} ModifyUserGroupsRequest::~ModifyUserGroupsRequest() {} @@ -55,12 +57,11 @@ std::vector ModifyUserGroupsRequest::getUser()con void ModifyUserGroupsRequest::setUser(const std::vector& user) { user_ = user; - int i = 0; - for(int i = 0; i!= user.size(); i++) { - auto obj = user.at(i); - std::string str ="User."+ std::to_string(i); - setCoreParameter(str + ".Name", obj.name); - setCoreParameter(str + ".Group", obj.group); + for(int dep1 = 0; dep1!= user.size(); dep1++) { + auto userObj = user.at(dep1); + std::string userObjStr = "User." + std::to_string(dep1); + setCoreParameter(userObjStr + ".Name", userObj.name); + setCoreParameter(userObjStr + ".Group", userObj.group); } } diff --git a/ehpc/src/model/ModifyUserPasswordsRequest.cc b/ehpc/src/model/ModifyUserPasswordsRequest.cc index 18c801336..e0cce5e0d 100644 --- a/ehpc/src/model/ModifyUserPasswordsRequest.cc +++ b/ehpc/src/model/ModifyUserPasswordsRequest.cc @@ -20,7 +20,9 @@ using AlibabaCloud::EHPC::Model::ModifyUserPasswordsRequest; ModifyUserPasswordsRequest::ModifyUserPasswordsRequest() : RpcServiceRequest("ehpc", "2018-04-12", "ModifyUserPasswords") -{} +{ + setMethod(HttpRequest::Method::Get); +} ModifyUserPasswordsRequest::~ModifyUserPasswordsRequest() {} @@ -55,12 +57,11 @@ std::vector ModifyUserPasswordsRequest::getUse void ModifyUserPasswordsRequest::setUser(const std::vector& user) { user_ = user; - int i = 0; - for(int i = 0; i!= user.size(); i++) { - auto obj = user.at(i); - std::string str ="User."+ std::to_string(i); - setCoreParameter(str + ".Password", obj.password); - setCoreParameter(str + ".Name", obj.name); + for(int dep1 = 0; dep1!= user.size(); dep1++) { + auto userObj = user.at(dep1); + std::string userObjStr = "User." + std::to_string(dep1); + setCoreParameter(userObjStr + ".Password", userObj.password); + setCoreParameter(userObjStr + ".Name", userObj.name); } } diff --git a/ehpc/src/model/ModifyVisualServicePasswdRequest.cc b/ehpc/src/model/ModifyVisualServicePasswdRequest.cc index 04bb5ec1d..994a99974 100644 --- a/ehpc/src/model/ModifyVisualServicePasswdRequest.cc +++ b/ehpc/src/model/ModifyVisualServicePasswdRequest.cc @@ -20,7 +20,9 @@ using AlibabaCloud::EHPC::Model::ModifyVisualServicePasswdRequest; ModifyVisualServicePasswdRequest::ModifyVisualServicePasswdRequest() : RpcServiceRequest("ehpc", "2018-04-12", "ModifyVisualServicePasswd") -{} +{ + setMethod(HttpRequest::Method::Get); +} ModifyVisualServicePasswdRequest::~ModifyVisualServicePasswdRequest() {} diff --git a/ehpc/src/model/MountNFSRequest.cc b/ehpc/src/model/MountNFSRequest.cc index dbc92b5b3..f6d3b5ae5 100644 --- a/ehpc/src/model/MountNFSRequest.cc +++ b/ehpc/src/model/MountNFSRequest.cc @@ -20,7 +20,9 @@ using AlibabaCloud::EHPC::Model::MountNFSRequest; MountNFSRequest::MountNFSRequest() : RpcServiceRequest("ehpc", "2018-04-12", "MountNFS") -{} +{ + setMethod(HttpRequest::Method::Get); +} MountNFSRequest::~MountNFSRequest() {} @@ -69,3 +71,14 @@ void MountNFSRequest::setNfsDir(const std::string& nfsDir) setCoreParameter("NfsDir", nfsDir); } +std::string MountNFSRequest::getProtocolType()const +{ + return protocolType_; +} + +void MountNFSRequest::setProtocolType(const std::string& protocolType) +{ + protocolType_ = protocolType; + setCoreParameter("ProtocolType", protocolType); +} + diff --git a/ehpc/src/model/PullImageRequest.cc b/ehpc/src/model/PullImageRequest.cc index d4876ec73..8e9205cb8 100644 --- a/ehpc/src/model/PullImageRequest.cc +++ b/ehpc/src/model/PullImageRequest.cc @@ -20,7 +20,9 @@ using AlibabaCloud::EHPC::Model::PullImageRequest; PullImageRequest::PullImageRequest() : RpcServiceRequest("ehpc", "2018-04-12", "PullImage") -{} +{ + setMethod(HttpRequest::Method::Get); +} PullImageRequest::~PullImageRequest() {} diff --git a/ehpc/src/model/QueryServicePackAndPriceRequest.cc b/ehpc/src/model/QueryServicePackAndPriceRequest.cc index ef34b3047..52e537753 100644 --- a/ehpc/src/model/QueryServicePackAndPriceRequest.cc +++ b/ehpc/src/model/QueryServicePackAndPriceRequest.cc @@ -20,7 +20,9 @@ using AlibabaCloud::EHPC::Model::QueryServicePackAndPriceRequest; QueryServicePackAndPriceRequest::QueryServicePackAndPriceRequest() : RpcServiceRequest("ehpc", "2018-04-12", "QueryServicePackAndPrice") -{} +{ + setMethod(HttpRequest::Method::Get); +} QueryServicePackAndPriceRequest::~QueryServicePackAndPriceRequest() {} diff --git a/ehpc/src/model/RecoverClusterRequest.cc b/ehpc/src/model/RecoverClusterRequest.cc index b6274ee77..642b62173 100644 --- a/ehpc/src/model/RecoverClusterRequest.cc +++ b/ehpc/src/model/RecoverClusterRequest.cc @@ -20,7 +20,9 @@ using AlibabaCloud::EHPC::Model::RecoverClusterRequest; RecoverClusterRequest::RecoverClusterRequest() : RpcServiceRequest("ehpc", "2018-04-12", "RecoverCluster") -{} +{ + setMethod(HttpRequest::Method::Get); +} RecoverClusterRequest::~RecoverClusterRequest() {} diff --git a/ehpc/src/model/RerunJobsRequest.cc b/ehpc/src/model/RerunJobsRequest.cc index c3ef8ef88..d91831adf 100644 --- a/ehpc/src/model/RerunJobsRequest.cc +++ b/ehpc/src/model/RerunJobsRequest.cc @@ -20,7 +20,9 @@ using AlibabaCloud::EHPC::Model::RerunJobsRequest; RerunJobsRequest::RerunJobsRequest() : RpcServiceRequest("ehpc", "2018-04-12", "RerunJobs") -{} +{ + setMethod(HttpRequest::Method::Get); +} RerunJobsRequest::~RerunJobsRequest() {} diff --git a/ehpc/src/model/ResetNodesRequest.cc b/ehpc/src/model/ResetNodesRequest.cc index 840f3323f..343c0f700 100644 --- a/ehpc/src/model/ResetNodesRequest.cc +++ b/ehpc/src/model/ResetNodesRequest.cc @@ -20,7 +20,9 @@ using AlibabaCloud::EHPC::Model::ResetNodesRequest; ResetNodesRequest::ResetNodesRequest() : RpcServiceRequest("ehpc", "2018-04-12", "ResetNodes") -{} +{ + setMethod(HttpRequest::Method::Get); +} ResetNodesRequest::~ResetNodesRequest() {} @@ -33,11 +35,10 @@ std::vector ResetNodesRequest::getInstance()const void ResetNodesRequest::setInstance(const std::vector& instance) { instance_ = instance; - int i = 0; - for(int i = 0; i!= instance.size(); i++) { - auto obj = instance.at(i); - std::string str ="Instance."+ std::to_string(i); - setCoreParameter(str + ".Id", obj.id); + for(int dep1 = 0; dep1!= instance.size(); dep1++) { + auto instanceObj = instance.at(dep1); + std::string instanceObjStr = "Instance." + std::to_string(dep1); + setCoreParameter(instanceObjStr + ".Id", instanceObj.id); } } diff --git a/ehpc/src/model/RunCloudMetricProfilingRequest.cc b/ehpc/src/model/RunCloudMetricProfilingRequest.cc index b55358a07..47a70ccaf 100644 --- a/ehpc/src/model/RunCloudMetricProfilingRequest.cc +++ b/ehpc/src/model/RunCloudMetricProfilingRequest.cc @@ -20,7 +20,9 @@ using AlibabaCloud::EHPC::Model::RunCloudMetricProfilingRequest; RunCloudMetricProfilingRequest::RunCloudMetricProfilingRequest() : RpcServiceRequest("ehpc", "2018-04-12", "RunCloudMetricProfiling") -{} +{ + setMethod(HttpRequest::Method::Get); +} RunCloudMetricProfilingRequest::~RunCloudMetricProfilingRequest() {} diff --git a/ehpc/src/model/SetAutoScaleConfigRequest.cc b/ehpc/src/model/SetAutoScaleConfigRequest.cc index e7d9c2939..571e77148 100644 --- a/ehpc/src/model/SetAutoScaleConfigRequest.cc +++ b/ehpc/src/model/SetAutoScaleConfigRequest.cc @@ -20,7 +20,9 @@ using AlibabaCloud::EHPC::Model::SetAutoScaleConfigRequest; SetAutoScaleConfigRequest::SetAutoScaleConfigRequest() : RpcServiceRequest("ehpc", "2018-04-12", "SetAutoScaleConfig") -{} +{ + setMethod(HttpRequest::Method::Get); +} SetAutoScaleConfigRequest::~SetAutoScaleConfigRequest() {} @@ -165,17 +167,25 @@ std::vector SetAutoScaleConfigRequest::getQue void SetAutoScaleConfigRequest::setQueues(const std::vector& queues) { queues_ = queues; - int i = 0; - for(int i = 0; i!= queues.size(); i++) { - auto obj = queues.at(i); - std::string str ="Queues."+ std::to_string(i); - setCoreParameter(str + ".SpotStrategy", obj.spotStrategy); - setCoreParameter(str + ".QueueName", obj.queueName); - setCoreParameter(str + ".InstanceTypes", std::to_string(obj.instanceTypes)); - setCoreParameter(str + ".InstanceType", obj.instanceType); - setCoreParameter(str + ".EnableAutoGrow", obj.enableAutoGrow ? "true" : "false"); - setCoreParameter(str + ".SpotPriceLimit", std::to_string(obj.spotPriceLimit)); - setCoreParameter(str + ".EnableAutoShrink", obj.enableAutoShrink ? "true" : "false"); + for(int dep1 = 0; dep1!= queues.size(); dep1++) { + auto queuesObj = queues.at(dep1); + std::string queuesObjStr = "Queues." + std::to_string(dep1); + setCoreParameter(queuesObjStr + ".SpotStrategy", queuesObj.spotStrategy); + setCoreParameter(queuesObjStr + ".QueueName", queuesObj.queueName); + for(int dep2 = 0; dep2!= queuesObj.instanceTypes.size(); dep2++) { + auto instanceTypesObj = queuesObj.instanceTypes.at(dep2); + std::string instanceTypesObjStr = queuesObjStr + "InstanceTypes." + std::to_string(dep2); + setCoreParameter(instanceTypesObjStr + ".SpotStrategy", instanceTypesObj.spotStrategy); + setCoreParameter(instanceTypesObjStr + ".VSwitchId", instanceTypesObj.vSwitchId); + setCoreParameter(instanceTypesObjStr + ".InstanceType", instanceTypesObj.instanceType); + setCoreParameter(instanceTypesObjStr + ".ZoneId", instanceTypesObj.zoneId); + setCoreParameter(instanceTypesObjStr + ".HostNamePrefix", instanceTypesObj.hostNamePrefix); + setCoreParameter(instanceTypesObjStr + ".SpotPriceLimit", std::to_string(instanceTypesObj.spotPriceLimit)); + } + setCoreParameter(queuesObjStr + ".InstanceType", queuesObj.instanceType); + setCoreParameter(queuesObjStr + ".EnableAutoGrow", queuesObj.enableAutoGrow ? "true" : "false"); + setCoreParameter(queuesObjStr + ".SpotPriceLimit", std::to_string(queuesObj.spotPriceLimit)); + setCoreParameter(queuesObjStr + ".EnableAutoShrink", queuesObj.enableAutoShrink ? "true" : "false"); } } diff --git a/ehpc/src/model/SetGWSInstanceUserRequest.cc b/ehpc/src/model/SetGWSInstanceUserRequest.cc index 0dc240edb..bb5c422a8 100644 --- a/ehpc/src/model/SetGWSInstanceUserRequest.cc +++ b/ehpc/src/model/SetGWSInstanceUserRequest.cc @@ -20,7 +20,9 @@ using AlibabaCloud::EHPC::Model::SetGWSInstanceUserRequest; SetGWSInstanceUserRequest::SetGWSInstanceUserRequest() : RpcServiceRequest("ehpc", "2018-04-12", "SetGWSInstanceUser") -{} +{ + setMethod(HttpRequest::Method::Get); +} SetGWSInstanceUserRequest::~SetGWSInstanceUserRequest() {} diff --git a/ehpc/src/model/SetJobUserRequest.cc b/ehpc/src/model/SetJobUserRequest.cc index f8f2a3343..88e5bda84 100644 --- a/ehpc/src/model/SetJobUserRequest.cc +++ b/ehpc/src/model/SetJobUserRequest.cc @@ -20,7 +20,9 @@ using AlibabaCloud::EHPC::Model::SetJobUserRequest; SetJobUserRequest::SetJobUserRequest() : RpcServiceRequest("ehpc", "2018-04-12", "SetJobUser") -{} +{ + setMethod(HttpRequest::Method::Get); +} SetJobUserRequest::~SetJobUserRequest() {} diff --git a/ehpc/src/model/SetQueueRequest.cc b/ehpc/src/model/SetQueueRequest.cc index c3ec23833..451e26f2d 100644 --- a/ehpc/src/model/SetQueueRequest.cc +++ b/ehpc/src/model/SetQueueRequest.cc @@ -20,7 +20,9 @@ using AlibabaCloud::EHPC::Model::SetQueueRequest; SetQueueRequest::SetQueueRequest() : RpcServiceRequest("ehpc", "2018-04-12", "SetQueue") -{} +{ + setMethod(HttpRequest::Method::Get); +} SetQueueRequest::~SetQueueRequest() {} @@ -66,11 +68,10 @@ std::vector SetQueueRequest::getNode()const void SetQueueRequest::setNode(const std::vector& node) { node_ = node; - int i = 0; - for(int i = 0; i!= node.size(); i++) { - auto obj = node.at(i); - std::string str ="Node."+ std::to_string(i); - setCoreParameter(str + ".Name", obj.name); + for(int dep1 = 0; dep1!= node.size(); dep1++) { + auto nodeObj = node.at(dep1); + std::string nodeObjStr = "Node." + std::to_string(dep1); + setCoreParameter(nodeObjStr + ".Name", nodeObj.name); } } diff --git a/ehpc/src/model/StartClusterRequest.cc b/ehpc/src/model/StartClusterRequest.cc index 061d626f4..7a2647581 100644 --- a/ehpc/src/model/StartClusterRequest.cc +++ b/ehpc/src/model/StartClusterRequest.cc @@ -20,7 +20,9 @@ using AlibabaCloud::EHPC::Model::StartClusterRequest; StartClusterRequest::StartClusterRequest() : RpcServiceRequest("ehpc", "2018-04-12", "StartCluster") -{} +{ + setMethod(HttpRequest::Method::Get); +} StartClusterRequest::~StartClusterRequest() {} diff --git a/ehpc/src/model/StartGWSInstanceRequest.cc b/ehpc/src/model/StartGWSInstanceRequest.cc index f68817a92..4c9cf798a 100644 --- a/ehpc/src/model/StartGWSInstanceRequest.cc +++ b/ehpc/src/model/StartGWSInstanceRequest.cc @@ -20,7 +20,9 @@ using AlibabaCloud::EHPC::Model::StartGWSInstanceRequest; StartGWSInstanceRequest::StartGWSInstanceRequest() : RpcServiceRequest("ehpc", "2018-04-12", "StartGWSInstance") -{} +{ + setMethod(HttpRequest::Method::Get); +} StartGWSInstanceRequest::~StartGWSInstanceRequest() {} diff --git a/ehpc/src/model/StartNodesRequest.cc b/ehpc/src/model/StartNodesRequest.cc index 51c8f6b30..0968d4f77 100644 --- a/ehpc/src/model/StartNodesRequest.cc +++ b/ehpc/src/model/StartNodesRequest.cc @@ -20,7 +20,9 @@ using AlibabaCloud::EHPC::Model::StartNodesRequest; StartNodesRequest::StartNodesRequest() : RpcServiceRequest("ehpc", "2018-04-12", "StartNodes") -{} +{ + setMethod(HttpRequest::Method::Get); +} StartNodesRequest::~StartNodesRequest() {} @@ -44,11 +46,10 @@ std::vector StartNodesRequest::getInstance()const void StartNodesRequest::setInstance(const std::vector& instance) { instance_ = instance; - int i = 0; - for(int i = 0; i!= instance.size(); i++) { - auto obj = instance.at(i); - std::string str ="Instance."+ std::to_string(i); - setCoreParameter(str + ".Id", obj.id); + for(int dep1 = 0; dep1!= instance.size(); dep1++) { + auto instanceObj = instance.at(dep1); + std::string instanceObjStr = "Instance." + std::to_string(dep1); + setCoreParameter(instanceObjStr + ".Id", instanceObj.id); } } diff --git a/ehpc/src/model/StartVisualServiceRequest.cc b/ehpc/src/model/StartVisualServiceRequest.cc index b396bc721..6403a7b6e 100644 --- a/ehpc/src/model/StartVisualServiceRequest.cc +++ b/ehpc/src/model/StartVisualServiceRequest.cc @@ -20,7 +20,9 @@ using AlibabaCloud::EHPC::Model::StartVisualServiceRequest; StartVisualServiceRequest::StartVisualServiceRequest() : RpcServiceRequest("ehpc", "2018-04-12", "StartVisualService") -{} +{ + setMethod(HttpRequest::Method::Get); +} StartVisualServiceRequest::~StartVisualServiceRequest() {} diff --git a/ehpc/src/model/StopClusterRequest.cc b/ehpc/src/model/StopClusterRequest.cc index d38e4f6cc..bb550f222 100644 --- a/ehpc/src/model/StopClusterRequest.cc +++ b/ehpc/src/model/StopClusterRequest.cc @@ -20,7 +20,9 @@ using AlibabaCloud::EHPC::Model::StopClusterRequest; StopClusterRequest::StopClusterRequest() : RpcServiceRequest("ehpc", "2018-04-12", "StopCluster") -{} +{ + setMethod(HttpRequest::Method::Get); +} StopClusterRequest::~StopClusterRequest() {} diff --git a/ehpc/src/model/StopGWSInstanceRequest.cc b/ehpc/src/model/StopGWSInstanceRequest.cc index 4a6a77267..33d08e126 100644 --- a/ehpc/src/model/StopGWSInstanceRequest.cc +++ b/ehpc/src/model/StopGWSInstanceRequest.cc @@ -20,7 +20,9 @@ using AlibabaCloud::EHPC::Model::StopGWSInstanceRequest; StopGWSInstanceRequest::StopGWSInstanceRequest() : RpcServiceRequest("ehpc", "2018-04-12", "StopGWSInstance") -{} +{ + setMethod(HttpRequest::Method::Get); +} StopGWSInstanceRequest::~StopGWSInstanceRequest() {} diff --git a/ehpc/src/model/StopJobsRequest.cc b/ehpc/src/model/StopJobsRequest.cc index 58668bc3e..de8d6ac44 100644 --- a/ehpc/src/model/StopJobsRequest.cc +++ b/ehpc/src/model/StopJobsRequest.cc @@ -20,7 +20,9 @@ using AlibabaCloud::EHPC::Model::StopJobsRequest; StopJobsRequest::StopJobsRequest() : RpcServiceRequest("ehpc", "2018-04-12", "StopJobs") -{} +{ + setMethod(HttpRequest::Method::Get); +} StopJobsRequest::~StopJobsRequest() {} diff --git a/ehpc/src/model/StopNodesRequest.cc b/ehpc/src/model/StopNodesRequest.cc index 0c803f757..a9ec5e7cd 100644 --- a/ehpc/src/model/StopNodesRequest.cc +++ b/ehpc/src/model/StopNodesRequest.cc @@ -20,7 +20,9 @@ using AlibabaCloud::EHPC::Model::StopNodesRequest; StopNodesRequest::StopNodesRequest() : RpcServiceRequest("ehpc", "2018-04-12", "StopNodes") -{} +{ + setMethod(HttpRequest::Method::Get); +} StopNodesRequest::~StopNodesRequest() {} @@ -44,11 +46,10 @@ std::vector StopNodesRequest::getInstance()const void StopNodesRequest::setInstance(const std::vector& instance) { instance_ = instance; - int i = 0; - for(int i = 0; i!= instance.size(); i++) { - auto obj = instance.at(i); - std::string str ="Instance."+ std::to_string(i); - setCoreParameter(str + ".Id", obj.id); + for(int dep1 = 0; dep1!= instance.size(); dep1++) { + auto instanceObj = instance.at(dep1); + std::string instanceObjStr = "Instance." + std::to_string(dep1); + setCoreParameter(instanceObjStr + ".Id", instanceObj.id); } } diff --git a/ehpc/src/model/StopVisualServiceRequest.cc b/ehpc/src/model/StopVisualServiceRequest.cc index ad11bfd5f..b74879493 100644 --- a/ehpc/src/model/StopVisualServiceRequest.cc +++ b/ehpc/src/model/StopVisualServiceRequest.cc @@ -20,7 +20,9 @@ using AlibabaCloud::EHPC::Model::StopVisualServiceRequest; StopVisualServiceRequest::StopVisualServiceRequest() : RpcServiceRequest("ehpc", "2018-04-12", "StopVisualService") -{} +{ + setMethod(HttpRequest::Method::Get); +} StopVisualServiceRequest::~StopVisualServiceRequest() {} diff --git a/ehpc/src/model/SubmitJobRequest.cc b/ehpc/src/model/SubmitJobRequest.cc index 730d68bc2..9021757a4 100644 --- a/ehpc/src/model/SubmitJobRequest.cc +++ b/ehpc/src/model/SubmitJobRequest.cc @@ -20,7 +20,9 @@ using AlibabaCloud::EHPC::Model::SubmitJobRequest; SubmitJobRequest::SubmitJobRequest() : RpcServiceRequest("ehpc", "2018-04-12", "SubmitJob") -{} +{ + setMethod(HttpRequest::Method::Get); +} SubmitJobRequest::~SubmitJobRequest() {} diff --git a/ehpc/src/model/UnbindAccountToClusterUserRequest.cc b/ehpc/src/model/UnbindAccountToClusterUserRequest.cc new file mode 100644 index 000000000..b4b495bcd --- /dev/null +++ b/ehpc/src/model/UnbindAccountToClusterUserRequest.cc @@ -0,0 +1,73 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed 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. + */ + +#include + +using AlibabaCloud::EHPC::Model::UnbindAccountToClusterUserRequest; + +UnbindAccountToClusterUserRequest::UnbindAccountToClusterUserRequest() : + RpcServiceRequest("ehpc", "2018-04-12", "UnbindAccountToClusterUser") +{ + setMethod(HttpRequest::Method::Get); +} + +UnbindAccountToClusterUserRequest::~UnbindAccountToClusterUserRequest() +{} + +std::string UnbindAccountToClusterUserRequest::getClusterId()const +{ + return clusterId_; +} + +void UnbindAccountToClusterUserRequest::setClusterId(const std::string& clusterId) +{ + clusterId_ = clusterId; + setCoreParameter("ClusterId", clusterId); +} + +std::string UnbindAccountToClusterUserRequest::getAccessKeyId()const +{ + return accessKeyId_; +} + +void UnbindAccountToClusterUserRequest::setAccessKeyId(const std::string& accessKeyId) +{ + accessKeyId_ = accessKeyId; + setCoreParameter("AccessKeyId", accessKeyId); +} + +std::string UnbindAccountToClusterUserRequest::getAccountUid()const +{ + return accountUid_; +} + +void UnbindAccountToClusterUserRequest::setAccountUid(const std::string& accountUid) +{ + accountUid_ = accountUid; + setCoreParameter("AccountUid", accountUid); +} + +std::string UnbindAccountToClusterUserRequest::getUserName()const +{ + return userName_; +} + +void UnbindAccountToClusterUserRequest::setUserName(const std::string& userName) +{ + userName_ = userName; + setCoreParameter("UserName", userName); +} + diff --git a/ehpc/src/model/UnbindAccountToClusterUserResult.cc b/ehpc/src/model/UnbindAccountToClusterUserResult.cc new file mode 100644 index 000000000..38ba04c0d --- /dev/null +++ b/ehpc/src/model/UnbindAccountToClusterUserResult.cc @@ -0,0 +1,44 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed 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. + */ + +#include +#include + +using namespace AlibabaCloud::EHPC; +using namespace AlibabaCloud::EHPC::Model; + +UnbindAccountToClusterUserResult::UnbindAccountToClusterUserResult() : + ServiceResult() +{} + +UnbindAccountToClusterUserResult::UnbindAccountToClusterUserResult(const std::string &payload) : + ServiceResult() +{ + parse(payload); +} + +UnbindAccountToClusterUserResult::~UnbindAccountToClusterUserResult() +{} + +void UnbindAccountToClusterUserResult::parse(const std::string &payload) +{ + Json::Reader reader; + Json::Value value; + reader.parse(payload, value); + setRequestId(value["RequestId"].asString()); + +} + diff --git a/ehpc/src/model/UninstallSoftwareRequest.cc b/ehpc/src/model/UninstallSoftwareRequest.cc index 7b8ca214e..a80233c5c 100644 --- a/ehpc/src/model/UninstallSoftwareRequest.cc +++ b/ehpc/src/model/UninstallSoftwareRequest.cc @@ -20,7 +20,9 @@ using AlibabaCloud::EHPC::Model::UninstallSoftwareRequest; UninstallSoftwareRequest::UninstallSoftwareRequest() : RpcServiceRequest("ehpc", "2018-04-12", "UninstallSoftware") -{} +{ + setMethod(HttpRequest::Method::Get); +} UninstallSoftwareRequest::~UninstallSoftwareRequest() {} diff --git a/ehpc/src/model/UpdateClusterVolumesRequest.cc b/ehpc/src/model/UpdateClusterVolumesRequest.cc index 836a85f72..491995ddd 100644 --- a/ehpc/src/model/UpdateClusterVolumesRequest.cc +++ b/ehpc/src/model/UpdateClusterVolumesRequest.cc @@ -20,7 +20,9 @@ using AlibabaCloud::EHPC::Model::UpdateClusterVolumesRequest; UpdateClusterVolumesRequest::UpdateClusterVolumesRequest() : RpcServiceRequest("ehpc", "2018-04-12", "UpdateClusterVolumes") -{} +{ + setMethod(HttpRequest::Method::Get); +} UpdateClusterVolumesRequest::~UpdateClusterVolumesRequest() {} @@ -33,19 +35,22 @@ std::vector UpdateClusterVolumes void UpdateClusterVolumesRequest::setAdditionalVolumes(const std::vector& additionalVolumes) { additionalVolumes_ = additionalVolumes; - int i = 0; - for(int i = 0; i!= additionalVolumes.size(); i++) { - auto obj = additionalVolumes.at(i); - std::string str ="AdditionalVolumes."+ std::to_string(i); - setCoreParameter(str + ".VolumeType", obj.volumeType); - setCoreParameter(str + ".VolumeProtocol", obj.volumeProtocol); - setCoreParameter(str + ".LocalDirectory", obj.localDirectory); - setCoreParameter(str + ".RemoteDirectory", obj.remoteDirectory); - setCoreParameter(str + ".Roles", std::to_string(obj.roles)); - setCoreParameter(str + ".VolumeId", obj.volumeId); - setCoreParameter(str + ".VolumeMountpoint", obj.volumeMountpoint); - setCoreParameter(str + ".Location", obj.location); - setCoreParameter(str + ".JobQueue", obj.jobQueue); + for(int dep1 = 0; dep1!= additionalVolumes.size(); dep1++) { + auto additionalVolumesObj = additionalVolumes.at(dep1); + std::string additionalVolumesObjStr = "AdditionalVolumes." + std::to_string(dep1); + setCoreParameter(additionalVolumesObjStr + ".VolumeType", additionalVolumesObj.volumeType); + setCoreParameter(additionalVolumesObjStr + ".VolumeProtocol", additionalVolumesObj.volumeProtocol); + setCoreParameter(additionalVolumesObjStr + ".LocalDirectory", additionalVolumesObj.localDirectory); + setCoreParameter(additionalVolumesObjStr + ".RemoteDirectory", additionalVolumesObj.remoteDirectory); + for(int dep2 = 0; dep2!= additionalVolumesObj.roles.size(); dep2++) { + auto rolesObj = additionalVolumesObj.roles.at(dep2); + std::string rolesObjStr = additionalVolumesObjStr + "Roles." + std::to_string(dep2); + setCoreParameter(rolesObjStr + ".Name", rolesObj.name); + } + setCoreParameter(additionalVolumesObjStr + ".VolumeId", additionalVolumesObj.volumeId); + setCoreParameter(additionalVolumesObjStr + ".VolumeMountpoint", additionalVolumesObj.volumeMountpoint); + setCoreParameter(additionalVolumesObjStr + ".Location", additionalVolumesObj.location); + setCoreParameter(additionalVolumesObjStr + ".JobQueue", additionalVolumesObj.jobQueue); } } diff --git a/ehpc/src/model/UpdateQueueConfigRequest.cc b/ehpc/src/model/UpdateQueueConfigRequest.cc index ad5323ee6..2a9657f75 100644 --- a/ehpc/src/model/UpdateQueueConfigRequest.cc +++ b/ehpc/src/model/UpdateQueueConfigRequest.cc @@ -20,7 +20,9 @@ using AlibabaCloud::EHPC::Model::UpdateQueueConfigRequest; UpdateQueueConfigRequest::UpdateQueueConfigRequest() : RpcServiceRequest("ehpc", "2018-04-12", "UpdateQueueConfig") -{} +{ + setMethod(HttpRequest::Method::Get); +} UpdateQueueConfigRequest::~UpdateQueueConfigRequest() {} diff --git a/ehpc/src/model/UpgradeClientRequest.cc b/ehpc/src/model/UpgradeClientRequest.cc index b3fb0a664..ac1311ef2 100644 --- a/ehpc/src/model/UpgradeClientRequest.cc +++ b/ehpc/src/model/UpgradeClientRequest.cc @@ -20,7 +20,9 @@ using AlibabaCloud::EHPC::Model::UpgradeClientRequest; UpgradeClientRequest::UpgradeClientRequest() : RpcServiceRequest("ehpc", "2018-04-12", "UpgradeClient") -{} +{ + setMethod(HttpRequest::Method::Get); +} UpgradeClientRequest::~UpgradeClientRequest() {}