1585346868/aliyun-openapi-cpp-sdk
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

AcceptInquiredSystemEvent adds Choice parameter.

Browse Source
This commit is contained in:
sdk-team
2021-04-22 07:36:19 +00:00
parent bfee7629d7
commit 863129ac92
61 changed files with 2761 additions and 65 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
CHANGELOG
View File

@@ -1,3 +1,7 @@
2021-04-22 Version: 1.36.696
- AcceptInquiredSystemEvent adds Choice parameter.
- DescribeInstanceHistoryEvents supports multiple resource types.
2021-04-22 Version: 1.36.695
- Support CEN latest Apis.

2
VERSION
View File

@@ -1 +1 @@
1.36.695
1.36.696

28
ecs/CMakeLists.txt
View File

@@ -89,6 +89,8 @@ set(ecs_public_header_model
include/alibabacloud/ecs/model/CreateCapacityReservationResult.h
include/alibabacloud/ecs/model/CreateCommandRequest.h
include/alibabacloud/ecs/model/CreateCommandResult.h
include/alibabacloud/ecs/model/CreateDedicatedBlockStorageClusterRequest.h
include/alibabacloud/ecs/model/CreateDedicatedBlockStorageClusterResult.h
include/alibabacloud/ecs/model/CreateDedicatedHostClusterRequest.h
include/alibabacloud/ecs/model/CreateDedicatedHostClusterResult.h
include/alibabacloud/ecs/model/CreateDemandRequest.h
@@ -97,6 +99,8 @@ set(ecs_public_header_model
include/alibabacloud/ecs/model/CreateDeploymentSetResult.h
include/alibabacloud/ecs/model/CreateDiskRequest.h
include/alibabacloud/ecs/model/CreateDiskResult.h
include/alibabacloud/ecs/model/CreateDiskReplicaPairRequest.h
include/alibabacloud/ecs/model/CreateDiskReplicaPairResult.h
include/alibabacloud/ecs/model/CreateElasticityAssuranceRequest.h
include/alibabacloud/ecs/model/CreateElasticityAssuranceResult.h
include/alibabacloud/ecs/model/CreateForwardEntryRequest.h
@@ -167,6 +171,8 @@ set(ecs_public_header_model
include/alibabacloud/ecs/model/DeleteDeploymentSetResult.h
include/alibabacloud/ecs/model/DeleteDiskRequest.h
include/alibabacloud/ecs/model/DeleteDiskResult.h
include/alibabacloud/ecs/model/DeleteDiskReplicaPairRequest.h
include/alibabacloud/ecs/model/DeleteDiskReplicaPairResult.h
include/alibabacloud/ecs/model/DeleteForwardEntryRequest.h
include/alibabacloud/ecs/model/DeleteForwardEntryResult.h
include/alibabacloud/ecs/model/DeleteHaVipRequest.h
@@ -249,6 +255,8 @@ set(ecs_public_header_model
include/alibabacloud/ecs/model/DescribeClustersResult.h
include/alibabacloud/ecs/model/DescribeCommandsRequest.h
include/alibabacloud/ecs/model/DescribeCommandsResult.h
include/alibabacloud/ecs/model/DescribeDedicatedBlockStorageClustersRequest.h
include/alibabacloud/ecs/model/DescribeDedicatedBlockStorageClustersResult.h
include/alibabacloud/ecs/model/DescribeDedicatedHostAutoRenewRequest.h
include/alibabacloud/ecs/model/DescribeDedicatedHostAutoRenewResult.h
include/alibabacloud/ecs/model/DescribeDedicatedHostClustersRequest.h
@@ -265,6 +273,8 @@ set(ecs_public_header_model
include/alibabacloud/ecs/model/DescribeDeploymentSetsResult.h
include/alibabacloud/ecs/model/DescribeDiskMonitorDataRequest.h
include/alibabacloud/ecs/model/DescribeDiskMonitorDataResult.h
include/alibabacloud/ecs/model/DescribeDiskReplicaPairsRequest.h
include/alibabacloud/ecs/model/DescribeDiskReplicaPairsResult.h
include/alibabacloud/ecs/model/DescribeDisksRequest.h
include/alibabacloud/ecs/model/DescribeDisksResult.h
include/alibabacloud/ecs/model/DescribeDisksFullStatusRequest.h
@@ -643,6 +653,8 @@ set(ecs_public_header_model
include/alibabacloud/ecs/model/RunInstancesResult.h
include/alibabacloud/ecs/model/SendFileRequest.h
include/alibabacloud/ecs/model/SendFileResult.h
include/alibabacloud/ecs/model/StartDiskReplicaPairRequest.h
include/alibabacloud/ecs/model/StartDiskReplicaPairResult.h
include/alibabacloud/ecs/model/StartElasticityAssuranceRequest.h
include/alibabacloud/ecs/model/StartElasticityAssuranceResult.h
include/alibabacloud/ecs/model/StartImagePipelineExecutionRequest.h
@@ -651,6 +663,8 @@ set(ecs_public_header_model
include/alibabacloud/ecs/model/StartInstanceResult.h
include/alibabacloud/ecs/model/StartInstancesRequest.h
include/alibabacloud/ecs/model/StartInstancesResult.h
include/alibabacloud/ecs/model/StopDiskReplicaPairRequest.h
include/alibabacloud/ecs/model/StopDiskReplicaPairResult.h
include/alibabacloud/ecs/model/StopInstanceRequest.h
include/alibabacloud/ecs/model/StopInstanceResult.h
include/alibabacloud/ecs/model/StopInstancesRequest.h
@@ -744,6 +758,8 @@ set(ecs_src
src/model/CreateCapacityReservationResult.cc
src/model/CreateCommandRequest.cc
src/model/CreateCommandResult.cc
src/model/CreateDedicatedBlockStorageClusterRequest.cc
src/model/CreateDedicatedBlockStorageClusterResult.cc
src/model/CreateDedicatedHostClusterRequest.cc
src/model/CreateDedicatedHostClusterResult.cc
src/model/CreateDemandRequest.cc
@@ -752,6 +768,8 @@ set(ecs_src
src/model/CreateDeploymentSetResult.cc
src/model/CreateDiskRequest.cc
src/model/CreateDiskResult.cc
src/model/CreateDiskReplicaPairRequest.cc
src/model/CreateDiskReplicaPairResult.cc
src/model/CreateElasticityAssuranceRequest.cc
src/model/CreateElasticityAssuranceResult.cc
src/model/CreateForwardEntryRequest.cc
@@ -822,6 +840,8 @@ set(ecs_src
src/model/DeleteDeploymentSetResult.cc
src/model/DeleteDiskRequest.cc
src/model/DeleteDiskResult.cc
src/model/DeleteDiskReplicaPairRequest.cc
src/model/DeleteDiskReplicaPairResult.cc
src/model/DeleteForwardEntryRequest.cc
src/model/DeleteForwardEntryResult.cc
src/model/DeleteHaVipRequest.cc
@@ -904,6 +924,8 @@ set(ecs_src
src/model/DescribeClustersResult.cc
src/model/DescribeCommandsRequest.cc
src/model/DescribeCommandsResult.cc
src/model/DescribeDedicatedBlockStorageClustersRequest.cc
src/model/DescribeDedicatedBlockStorageClustersResult.cc
src/model/DescribeDedicatedHostAutoRenewRequest.cc
src/model/DescribeDedicatedHostAutoRenewResult.cc
src/model/DescribeDedicatedHostClustersRequest.cc
@@ -920,6 +942,8 @@ set(ecs_src
src/model/DescribeDeploymentSetsResult.cc
src/model/DescribeDiskMonitorDataRequest.cc
src/model/DescribeDiskMonitorDataResult.cc
src/model/DescribeDiskReplicaPairsRequest.cc
src/model/DescribeDiskReplicaPairsResult.cc
src/model/DescribeDisksRequest.cc
src/model/DescribeDisksResult.cc
src/model/DescribeDisksFullStatusRequest.cc
@@ -1298,6 +1322,8 @@ set(ecs_src
src/model/RunInstancesResult.cc
src/model/SendFileRequest.cc
src/model/SendFileResult.cc
src/model/StartDiskReplicaPairRequest.cc
src/model/StartDiskReplicaPairResult.cc
src/model/StartElasticityAssuranceRequest.cc
src/model/StartElasticityAssuranceResult.cc
src/model/StartImagePipelineExecutionRequest.cc
@@ -1306,6 +1332,8 @@ set(ecs_src
src/model/StartInstanceResult.cc
src/model/StartInstancesRequest.cc
src/model/StartInstancesResult.cc
src/model/StopDiskReplicaPairRequest.cc
src/model/StopDiskReplicaPairResult.cc
src/model/StopInstanceRequest.cc
src/model/StopInstanceResult.cc
src/model/StopInstancesRequest.cc

56
ecs/include/alibabacloud/ecs/EcsClient.h
View File

@@ -90,6 +90,8 @@
#include "model/CreateCapacityReservationResult.h"
#include "model/CreateCommandRequest.h"
#include "model/CreateCommandResult.h"
#include "model/CreateDedicatedBlockStorageClusterRequest.h"
#include "model/CreateDedicatedBlockStorageClusterResult.h"
#include "model/CreateDedicatedHostClusterRequest.h"
#include "model/CreateDedicatedHostClusterResult.h"
#include "model/CreateDemandRequest.h"
@@ -98,6 +100,8 @@
#include "model/CreateDeploymentSetResult.h"
#include "model/CreateDiskRequest.h"
#include "model/CreateDiskResult.h"
#include "model/CreateDiskReplicaPairRequest.h"
#include "model/CreateDiskReplicaPairResult.h"
#include "model/CreateElasticityAssuranceRequest.h"
#include "model/CreateElasticityAssuranceResult.h"
#include "model/CreateForwardEntryRequest.h"
@@ -168,6 +172,8 @@
#include "model/DeleteDeploymentSetResult.h"
#include "model/DeleteDiskRequest.h"
#include "model/DeleteDiskResult.h"
#include "model/DeleteDiskReplicaPairRequest.h"
#include "model/DeleteDiskReplicaPairResult.h"
#include "model/DeleteForwardEntryRequest.h"
#include "model/DeleteForwardEntryResult.h"
#include "model/DeleteHaVipRequest.h"
@@ -250,6 +256,8 @@
#include "model/DescribeClustersResult.h"
#include "model/DescribeCommandsRequest.h"
#include "model/DescribeCommandsResult.h"
#include "model/DescribeDedicatedBlockStorageClustersRequest.h"
#include "model/DescribeDedicatedBlockStorageClustersResult.h"
#include "model/DescribeDedicatedHostAutoRenewRequest.h"
#include "model/DescribeDedicatedHostAutoRenewResult.h"
#include "model/DescribeDedicatedHostClustersRequest.h"
@@ -266,6 +274,8 @@
#include "model/DescribeDeploymentSetsResult.h"
#include "model/DescribeDiskMonitorDataRequest.h"
#include "model/DescribeDiskMonitorDataResult.h"
#include "model/DescribeDiskReplicaPairsRequest.h"
#include "model/DescribeDiskReplicaPairsResult.h"
#include "model/DescribeDisksRequest.h"
#include "model/DescribeDisksResult.h"
#include "model/DescribeDisksFullStatusRequest.h"
@@ -644,6 +654,8 @@
#include "model/RunInstancesResult.h"
#include "model/SendFileRequest.h"
#include "model/SendFileResult.h"
#include "model/StartDiskReplicaPairRequest.h"
#include "model/StartDiskReplicaPairResult.h"
#include "model/StartElasticityAssuranceRequest.h"
#include "model/StartElasticityAssuranceResult.h"
#include "model/StartImagePipelineExecutionRequest.h"
@@ -652,6 +664,8 @@
#include "model/StartInstanceResult.h"
#include "model/StartInstancesRequest.h"
#include "model/StartInstancesResult.h"
#include "model/StopDiskReplicaPairRequest.h"
#include "model/StopDiskReplicaPairResult.h"
#include "model/StopInstanceRequest.h"
#include "model/StopInstanceResult.h"
#include "model/StopInstancesRequest.h"
@@ -785,6 +799,9 @@ namespace AlibabaCloud
typedef Outcome<Error, Model::CreateCommandResult> CreateCommandOutcome;
typedef std::future<CreateCommandOutcome> CreateCommandOutcomeCallable;
typedef std::function<void(const EcsClient*, const Model::CreateCommandRequest&, const CreateCommandOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateCommandAsyncHandler;
typedef Outcome<Error, Model::CreateDedicatedBlockStorageClusterResult> CreateDedicatedBlockStorageClusterOutcome;
typedef std::future<CreateDedicatedBlockStorageClusterOutcome> CreateDedicatedBlockStorageClusterOutcomeCallable;
typedef std::function<void(const EcsClient*, const Model::CreateDedicatedBlockStorageClusterRequest&, const CreateDedicatedBlockStorageClusterOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateDedicatedBlockStorageClusterAsyncHandler;
typedef Outcome<Error, Model::CreateDedicatedHostClusterResult> CreateDedicatedHostClusterOutcome;
typedef std::future<CreateDedicatedHostClusterOutcome> CreateDedicatedHostClusterOutcomeCallable;
typedef std::function<void(const EcsClient*, const Model::CreateDedicatedHostClusterRequest&, const CreateDedicatedHostClusterOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateDedicatedHostClusterAsyncHandler;
@@ -797,6 +814,9 @@ namespace AlibabaCloud
typedef Outcome<Error, Model::CreateDiskResult> CreateDiskOutcome;
typedef std::future<CreateDiskOutcome> CreateDiskOutcomeCallable;
typedef std::function<void(const EcsClient*, const Model::CreateDiskRequest&, const CreateDiskOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateDiskAsyncHandler;
typedef Outcome<Error, Model::CreateDiskReplicaPairResult> CreateDiskReplicaPairOutcome;
typedef std::future<CreateDiskReplicaPairOutcome> CreateDiskReplicaPairOutcomeCallable;
typedef std::function<void(const EcsClient*, const Model::CreateDiskReplicaPairRequest&, const CreateDiskReplicaPairOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateDiskReplicaPairAsyncHandler;
typedef Outcome<Error, Model::CreateElasticityAssuranceResult> CreateElasticityAssuranceOutcome;
typedef std::future<CreateElasticityAssuranceOutcome> CreateElasticityAssuranceOutcomeCallable;
typedef std::function<void(const EcsClient*, const Model::CreateElasticityAssuranceRequest&, const CreateElasticityAssuranceOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateElasticityAssuranceAsyncHandler;
@@ -902,6 +922,9 @@ namespace AlibabaCloud
typedef Outcome<Error, Model::DeleteDiskResult> DeleteDiskOutcome;
typedef std::future<DeleteDiskOutcome> DeleteDiskOutcomeCallable;
typedef std::function<void(const EcsClient*, const Model::DeleteDiskRequest&, const DeleteDiskOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteDiskAsyncHandler;
typedef Outcome<Error, Model::DeleteDiskReplicaPairResult> DeleteDiskReplicaPairOutcome;
typedef std::future<DeleteDiskReplicaPairOutcome> DeleteDiskReplicaPairOutcomeCallable;
typedef std::function<void(const EcsClient*, const Model::DeleteDiskReplicaPairRequest&, const DeleteDiskReplicaPairOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteDiskReplicaPairAsyncHandler;
typedef Outcome<Error, Model::DeleteForwardEntryResult> DeleteForwardEntryOutcome;
typedef std::future<DeleteForwardEntryOutcome> DeleteForwardEntryOutcomeCallable;
typedef std::function<void(const EcsClient*, const Model::DeleteForwardEntryRequest&, const DeleteForwardEntryOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteForwardEntryAsyncHandler;
@@ -1025,6 +1048,9 @@ namespace AlibabaCloud
typedef Outcome<Error, Model::DescribeCommandsResult> DescribeCommandsOutcome;
typedef std::future<DescribeCommandsOutcome> DescribeCommandsOutcomeCallable;
typedef std::function<void(const EcsClient*, const Model::DescribeCommandsRequest&, const DescribeCommandsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeCommandsAsyncHandler;
typedef Outcome<Error, Model::DescribeDedicatedBlockStorageClustersResult> DescribeDedicatedBlockStorageClustersOutcome;
typedef std::future<DescribeDedicatedBlockStorageClustersOutcome> DescribeDedicatedBlockStorageClustersOutcomeCallable;
typedef std::function<void(const EcsClient*, const Model::DescribeDedicatedBlockStorageClustersRequest&, const DescribeDedicatedBlockStorageClustersOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeDedicatedBlockStorageClustersAsyncHandler;
typedef Outcome<Error, Model::DescribeDedicatedHostAutoRenewResult> DescribeDedicatedHostAutoRenewOutcome;
typedef std::future<DescribeDedicatedHostAutoRenewOutcome> DescribeDedicatedHostAutoRenewOutcomeCallable;
typedef std::function<void(const EcsClient*, const Model::DescribeDedicatedHostAutoRenewRequest&, const DescribeDedicatedHostAutoRenewOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeDedicatedHostAutoRenewAsyncHandler;
@@ -1049,6 +1075,9 @@ namespace AlibabaCloud
typedef Outcome<Error, Model::DescribeDiskMonitorDataResult> DescribeDiskMonitorDataOutcome;
typedef std::future<DescribeDiskMonitorDataOutcome> DescribeDiskMonitorDataOutcomeCallable;
typedef std::function<void(const EcsClient*, const Model::DescribeDiskMonitorDataRequest&, const DescribeDiskMonitorDataOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeDiskMonitorDataAsyncHandler;
typedef Outcome<Error, Model::DescribeDiskReplicaPairsResult> DescribeDiskReplicaPairsOutcome;
typedef std::future<DescribeDiskReplicaPairsOutcome> DescribeDiskReplicaPairsOutcomeCallable;
typedef std::function<void(const EcsClient*, const Model::DescribeDiskReplicaPairsRequest&, const DescribeDiskReplicaPairsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeDiskReplicaPairsAsyncHandler;
typedef Outcome<Error, Model::DescribeDisksResult> DescribeDisksOutcome;
typedef std::future<DescribeDisksOutcome> DescribeDisksOutcomeCallable;
typedef std::function<void(const EcsClient*, const Model::DescribeDisksRequest&, const DescribeDisksOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeDisksAsyncHandler;
@@ -1616,6 +1645,9 @@ namespace AlibabaCloud
typedef Outcome<Error, Model::SendFileResult> SendFileOutcome;
typedef std::future<SendFileOutcome> SendFileOutcomeCallable;
typedef std::function<void(const EcsClient*, const Model::SendFileRequest&, const SendFileOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> SendFileAsyncHandler;
typedef Outcome<Error, Model::StartDiskReplicaPairResult> StartDiskReplicaPairOutcome;
typedef std::future<StartDiskReplicaPairOutcome> StartDiskReplicaPairOutcomeCallable;
typedef std::function<void(const EcsClient*, const Model::StartDiskReplicaPairRequest&, const StartDiskReplicaPairOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> StartDiskReplicaPairAsyncHandler;
typedef Outcome<Error, Model::StartElasticityAssuranceResult> StartElasticityAssuranceOutcome;
typedef std::future<StartElasticityAssuranceOutcome> StartElasticityAssuranceOutcomeCallable;
typedef std::function<void(const EcsClient*, const Model::StartElasticityAssuranceRequest&, const StartElasticityAssuranceOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> StartElasticityAssuranceAsyncHandler;
@@ -1628,6 +1660,9 @@ namespace AlibabaCloud
typedef Outcome<Error, Model::StartInstancesResult> StartInstancesOutcome;
typedef std::future<StartInstancesOutcome> StartInstancesOutcomeCallable;
typedef std::function<void(const EcsClient*, const Model::StartInstancesRequest&, const StartInstancesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> StartInstancesAsyncHandler;
typedef Outcome<Error, Model::StopDiskReplicaPairResult> StopDiskReplicaPairOutcome;
typedef std::future<StopDiskReplicaPairOutcome> StopDiskReplicaPairOutcomeCallable;
typedef std::function<void(const EcsClient*, const Model::StopDiskReplicaPairRequest&, const StopDiskReplicaPairOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> StopDiskReplicaPairAsyncHandler;
typedef Outcome<Error, Model::StopInstanceResult> StopInstanceOutcome;
typedef std::future<StopInstanceOutcome> StopInstanceOutcomeCallable;
typedef std::function<void(const EcsClient*, const Model::StopInstanceRequest&, const StopInstanceOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> StopInstanceAsyncHandler;
@@ -1768,6 +1803,9 @@ namespace AlibabaCloud
CreateCommandOutcome createCommand(const Model::CreateCommandRequest &request)const;
void createCommandAsync(const Model::CreateCommandRequest& request, const CreateCommandAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
CreateCommandOutcomeCallable createCommandCallable(const Model::CreateCommandRequest& request) const;
CreateDedicatedBlockStorageClusterOutcome createDedicatedBlockStorageCluster(const Model::CreateDedicatedBlockStorageClusterRequest &request)const;
void createDedicatedBlockStorageClusterAsync(const Model::CreateDedicatedBlockStorageClusterRequest& request, const CreateDedicatedBlockStorageClusterAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
CreateDedicatedBlockStorageClusterOutcomeCallable createDedicatedBlockStorageClusterCallable(const Model::CreateDedicatedBlockStorageClusterRequest& request) const;
CreateDedicatedHostClusterOutcome createDedicatedHostCluster(const Model::CreateDedicatedHostClusterRequest &request)const;
void createDedicatedHostClusterAsync(const Model::CreateDedicatedHostClusterRequest& request, const CreateDedicatedHostClusterAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
CreateDedicatedHostClusterOutcomeCallable createDedicatedHostClusterCallable(const Model::CreateDedicatedHostClusterRequest& request) const;
@@ -1780,6 +1818,9 @@ namespace AlibabaCloud
CreateDiskOutcome createDisk(const Model::CreateDiskRequest &request)const;
void createDiskAsync(const Model::CreateDiskRequest& request, const CreateDiskAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
CreateDiskOutcomeCallable createDiskCallable(const Model::CreateDiskRequest& request) const;
CreateDiskReplicaPairOutcome createDiskReplicaPair(const Model::CreateDiskReplicaPairRequest &request)const;
void createDiskReplicaPairAsync(const Model::CreateDiskReplicaPairRequest& request, const CreateDiskReplicaPairAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
CreateDiskReplicaPairOutcomeCallable createDiskReplicaPairCallable(const Model::CreateDiskReplicaPairRequest& request) const;
CreateElasticityAssuranceOutcome createElasticityAssurance(const Model::CreateElasticityAssuranceRequest &request)const;
void createElasticityAssuranceAsync(const Model::CreateElasticityAssuranceRequest& request, const CreateElasticityAssuranceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
CreateElasticityAssuranceOutcomeCallable createElasticityAssuranceCallable(const Model::CreateElasticityAssuranceRequest& request) const;
@@ -1885,6 +1926,9 @@ namespace AlibabaCloud
DeleteDiskOutcome deleteDisk(const Model::DeleteDiskRequest &request)const;
void deleteDiskAsync(const Model::DeleteDiskRequest& request, const DeleteDiskAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DeleteDiskOutcomeCallable deleteDiskCallable(const Model::DeleteDiskRequest& request) const;
DeleteDiskReplicaPairOutcome deleteDiskReplicaPair(const Model::DeleteDiskReplicaPairRequest &request)const;
void deleteDiskReplicaPairAsync(const Model::DeleteDiskReplicaPairRequest& request, const DeleteDiskReplicaPairAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DeleteDiskReplicaPairOutcomeCallable deleteDiskReplicaPairCallable(const Model::DeleteDiskReplicaPairRequest& request) const;
DeleteForwardEntryOutcome deleteForwardEntry(const Model::DeleteForwardEntryRequest &request)const;
void deleteForwardEntryAsync(const Model::DeleteForwardEntryRequest& request, const DeleteForwardEntryAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DeleteForwardEntryOutcomeCallable deleteForwardEntryCallable(const Model::DeleteForwardEntryRequest& request) const;
@@ -2008,6 +2052,9 @@ namespace AlibabaCloud
DescribeCommandsOutcome describeCommands(const Model::DescribeCommandsRequest &request)const;
void describeCommandsAsync(const Model::DescribeCommandsRequest& request, const DescribeCommandsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeCommandsOutcomeCallable describeCommandsCallable(const Model::DescribeCommandsRequest& request) const;
DescribeDedicatedBlockStorageClustersOutcome describeDedicatedBlockStorageClusters(const Model::DescribeDedicatedBlockStorageClustersRequest &request)const;
void describeDedicatedBlockStorageClustersAsync(const Model::DescribeDedicatedBlockStorageClustersRequest& request, const DescribeDedicatedBlockStorageClustersAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeDedicatedBlockStorageClustersOutcomeCallable describeDedicatedBlockStorageClustersCallable(const Model::DescribeDedicatedBlockStorageClustersRequest& request) const;
DescribeDedicatedHostAutoRenewOutcome describeDedicatedHostAutoRenew(const Model::DescribeDedicatedHostAutoRenewRequest &request)const;
void describeDedicatedHostAutoRenewAsync(const Model::DescribeDedicatedHostAutoRenewRequest& request, const DescribeDedicatedHostAutoRenewAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeDedicatedHostAutoRenewOutcomeCallable describeDedicatedHostAutoRenewCallable(const Model::DescribeDedicatedHostAutoRenewRequest& request) const;
@@ -2032,6 +2079,9 @@ namespace AlibabaCloud
DescribeDiskMonitorDataOutcome describeDiskMonitorData(const Model::DescribeDiskMonitorDataRequest &request)const;
void describeDiskMonitorDataAsync(const Model::DescribeDiskMonitorDataRequest& request, const DescribeDiskMonitorDataAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeDiskMonitorDataOutcomeCallable describeDiskMonitorDataCallable(const Model::DescribeDiskMonitorDataRequest& request) const;
DescribeDiskReplicaPairsOutcome describeDiskReplicaPairs(const Model::DescribeDiskReplicaPairsRequest &request)const;
void describeDiskReplicaPairsAsync(const Model::DescribeDiskReplicaPairsRequest& request, const DescribeDiskReplicaPairsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeDiskReplicaPairsOutcomeCallable describeDiskReplicaPairsCallable(const Model::DescribeDiskReplicaPairsRequest& request) const;
DescribeDisksOutcome describeDisks(const Model::DescribeDisksRequest &request)const;
void describeDisksAsync(const Model::DescribeDisksRequest& request, const DescribeDisksAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeDisksOutcomeCallable describeDisksCallable(const Model::DescribeDisksRequest& request) const;
@@ -2599,6 +2649,9 @@ namespace AlibabaCloud
SendFileOutcome sendFile(const Model::SendFileRequest &request)const;
void sendFileAsync(const Model::SendFileRequest& request, const SendFileAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
SendFileOutcomeCallable sendFileCallable(const Model::SendFileRequest& request) const;
StartDiskReplicaPairOutcome startDiskReplicaPair(const Model::StartDiskReplicaPairRequest &request)const;
void startDiskReplicaPairAsync(const Model::StartDiskReplicaPairRequest& request, const StartDiskReplicaPairAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
StartDiskReplicaPairOutcomeCallable startDiskReplicaPairCallable(const Model::StartDiskReplicaPairRequest& request) const;
StartElasticityAssuranceOutcome startElasticityAssurance(const Model::StartElasticityAssuranceRequest &request)const;
void startElasticityAssuranceAsync(const Model::StartElasticityAssuranceRequest& request, const StartElasticityAssuranceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
StartElasticityAssuranceOutcomeCallable startElasticityAssuranceCallable(const Model::StartElasticityAssuranceRequest& request) const;
@@ -2611,6 +2664,9 @@ namespace AlibabaCloud
StartInstancesOutcome startInstances(const Model::StartInstancesRequest &request)const;
void startInstancesAsync(const Model::StartInstancesRequest& request, const StartInstancesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
StartInstancesOutcomeCallable startInstancesCallable(const Model::StartInstancesRequest& request) const;
StopDiskReplicaPairOutcome stopDiskReplicaPair(const Model::StopDiskReplicaPairRequest &request)const;
void stopDiskReplicaPairAsync(const Model::StopDiskReplicaPairRequest& request, const StopDiskReplicaPairAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
StopDiskReplicaPairOutcomeCallable stopDiskReplicaPairCallable(const Model::StopDiskReplicaPairRequest& request) const;
StopInstanceOutcome stopInstance(const Model::StopInstanceRequest &request)const;
void stopInstanceAsync(const Model::StopInstanceRequest& request, const StopInstanceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
StopInstanceOutcomeCallable stopInstanceCallable(const Model::StopInstanceRequest& request) const;

3
ecs/include/alibabacloud/ecs/model/AcceptInquiredSystemEventRequest.h
View File

@@ -47,6 +47,8 @@ namespace AlibabaCloud
void setOwnerAccount(const std::string& ownerAccount);
long getOwnerId()const;
void setOwnerId(long ownerId);
std::string getChoice()const;
void setChoice(const std::string& choice);
private:
std::string eventId_;
@@ -55,6 +57,7 @@ namespace AlibabaCloud
std::string resourceOwnerAccount_;
std::string ownerAccount_;
long ownerId_;
std::string choice_;
};
}

90
ecs/include/alibabacloud/ecs/model/CreateDedicatedBlockStorageClusterRequest.h Normal file
View File

@@ -0,0 +1,90 @@
/*
* 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_ECS_MODEL_CREATEDEDICATEDBLOCKSTORAGECLUSTERREQUEST_H_
#define ALIBABACLOUD_ECS_MODEL_CREATEDEDICATEDBLOCKSTORAGECLUSTERREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/ecs/EcsExport.h>
namespace AlibabaCloud
{
namespace Ecs
{
namespace Model
{
class ALIBABACLOUD_ECS_EXPORT CreateDedicatedBlockStorageClusterRequest : public RpcServiceRequest
{
public:
CreateDedicatedBlockStorageClusterRequest();
~CreateDedicatedBlockStorageClusterRequest();
long getResourceOwnerId()const;
void setResourceOwnerId(long resourceOwnerId);
std::string getDedicatedBlockStorageClusterName()const;
void setDedicatedBlockStorageClusterName(const std::string& dedicatedBlockStorageClusterName);
std::string getClientToken()const;
void setClientToken(const std::string& clientToken);
std::string getDescription()const;
void setDescription(const std::string& description);
int getCapacity()const;
void setCapacity(int capacity);
std::string getRegionId()const;
void setRegionId(const std::string& regionId);
int getPeriod()const;
void setPeriod(int period);
std::string getFromApp()const;
void setFromApp(const std::string& fromApp);
std::string getResourceOwnerAccount()const;
void setResourceOwnerAccount(const std::string& resourceOwnerAccount);
std::string getPerformanceLevel()const;
void setPerformanceLevel(const std::string& performanceLevel);
std::string getOwnerAccount()const;
void setOwnerAccount(const std::string& ownerAccount);
long getOwnerId()const;
void setOwnerId(long ownerId);
std::string getPeriodUnit()const;
void setPeriodUnit(const std::string& periodUnit);
std::string getZoneId()const;
void setZoneId(const std::string& zoneId);
std::string getCategory()const;
void setCategory(const std::string& category);
private:
long resourceOwnerId_;
std::string dedicatedBlockStorageClusterName_;
std::string clientToken_;
std::string description_;
int capacity_;
std::string regionId_;
int period_;
std::string fromApp_;
std::string resourceOwnerAccount_;
std::string performanceLevel_;
std::string ownerAccount_;
long ownerId_;
std::string periodUnit_;
std::string zoneId_;
std::string category_;
};
}
}
}
#endif // !ALIBABACLOUD_ECS_MODEL_CREATEDEDICATEDBLOCKSTORAGECLUSTERREQUEST_H_

53
ecs/include/alibabacloud/ecs/model/CreateDedicatedBlockStorageClusterResult.h Normal file
View File

@@ -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_ECS_MODEL_CREATEDEDICATEDBLOCKSTORAGECLUSTERRESULT_H_
#define ALIBABACLOUD_ECS_MODEL_CREATEDEDICATEDBLOCKSTORAGECLUSTERRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/ecs/EcsExport.h>
namespace AlibabaCloud
{
namespace Ecs
{
namespace Model
{
class ALIBABACLOUD_ECS_EXPORT CreateDedicatedBlockStorageClusterResult : public ServiceResult
{
public:
CreateDedicatedBlockStorageClusterResult();
explicit CreateDedicatedBlockStorageClusterResult(const std::string &payload);
~CreateDedicatedBlockStorageClusterResult();
std::string getDedicatedBlockStorageClusterOrderId()const;
std::string getDedicatedBlockStorageClusterId()const;
protected:
void parse(const std::string &payload);
private:
std::string dedicatedBlockStorageClusterOrderId_;
std::string dedicatedBlockStorageClusterId_;
};
}
}
}
#endif // !ALIBABACLOUD_ECS_MODEL_CREATEDEDICATEDBLOCKSTORAGECLUSTERRESULT_H_

78
ecs/include/alibabacloud/ecs/model/CreateDiskReplicaPairRequest.h Normal file
View File

@@ -0,0 +1,78 @@
/*
* 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_ECS_MODEL_CREATEDISKREPLICAPAIRREQUEST_H_
#define ALIBABACLOUD_ECS_MODEL_CREATEDISKREPLICAPAIRREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/ecs/EcsExport.h>
namespace AlibabaCloud
{
namespace Ecs
{
namespace Model
{
class ALIBABACLOUD_ECS_EXPORT CreateDiskReplicaPairRequest : public RpcServiceRequest
{
public:
CreateDiskReplicaPairRequest();
~CreateDiskReplicaPairRequest();
long getResourceOwnerId()const;
void setResourceOwnerId(long resourceOwnerId);
std::string getPairName()const;
void setPairName(const std::string& pairName);
std::string getDestinationRegionId()const;
void setDestinationRegionId(const std::string& destinationRegionId);
std::string getDescription()const;
void setDescription(const std::string& description);
std::string getRegionId()const;
void setRegionId(const std::string& regionId);
std::string getDiskId()const;
void setDiskId(const std::string& diskId);
int getAsyncCycle()const;
void setAsyncCycle(int asyncCycle);
std::string getResourceOwnerAccount()const;
void setResourceOwnerAccount(const std::string& resourceOwnerAccount);
std::string getOwnerAccount()const;
void setOwnerAccount(const std::string& ownerAccount);
long getOwnerId()const;
void setOwnerId(long ownerId);
std::string getDestinationDiskId()const;
void setDestinationDiskId(const std::string& destinationDiskId);
private:
long resourceOwnerId_;
std::string pairName_;
std::string destinationRegionId_;
std::string description_;
std::string regionId_;
std::string diskId_;
int asyncCycle_;
std::string resourceOwnerAccount_;
std::string ownerAccount_;
long ownerId_;
std::string destinationDiskId_;
};
}
}
}
#endif // !ALIBABACLOUD_ECS_MODEL_CREATEDISKREPLICAPAIRREQUEST_H_

51
ecs/include/alibabacloud/ecs/model/CreateDiskReplicaPairResult.h Normal file
View File

@@ -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_ECS_MODEL_CREATEDISKREPLICAPAIRRESULT_H_
#define ALIBABACLOUD_ECS_MODEL_CREATEDISKREPLICAPAIRRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/ecs/EcsExport.h>
namespace AlibabaCloud
{
namespace Ecs
{
namespace Model
{
class ALIBABACLOUD_ECS_EXPORT CreateDiskReplicaPairResult : public ServiceResult
{
public:
CreateDiskReplicaPairResult();
explicit CreateDiskReplicaPairResult(const std::string &payload);
~CreateDiskReplicaPairResult();
std::string getPairId()const;
protected:
void parse(const std::string &payload);
private:
std::string pairId_;
};
}
}
}
#endif // !ALIBABACLOUD_ECS_MODEL_CREATEDISKREPLICAPAIRRESULT_H_

3
ecs/include/alibabacloud/ecs/model/CreateDiskRequest.h
View File

@@ -73,6 +73,8 @@ namespace AlibabaCloud
void setArn(const std::vector<Arn>& arn);
std::string getAdvancedFeatures()const;
void setAdvancedFeatures(const std::string& advancedFeatures);
std::string getDedicatedBlockStorageClusterId()const;
void setDedicatedBlockStorageClusterId(const std::string& dedicatedBlockStorageClusterId);
std::string getResourceOwnerAccount()const;
void setResourceOwnerAccount(const std::string& resourceOwnerAccount);
std::string getPerformanceLevel()const;
@@ -108,6 +110,7 @@ namespace AlibabaCloud
std::vector<Tag> tag_;
std::vector<Arn> arn_;
std::string advancedFeatures_;
std::string dedicatedBlockStorageClusterId_;
std::string resourceOwnerAccount_;
std::string performanceLevel_;
std::string ownerAccount_;

6
ecs/include/alibabacloud/ecs/model/CreateNetworkInterfaceRequest.h
View File

@@ -71,10 +71,14 @@ namespace AlibabaCloud
void setResourceOwnerAccount(const std::string& resourceOwnerAccount);
std::string getOwnerAccount()const;
void setOwnerAccount(const std::string& ownerAccount);
int getQueuePairNumber()const;
void setQueuePairNumber(int queuePairNumber);
long getOwnerId()const;
void setOwnerId(long ownerId);
std::vector<std::string> getSecurityGroupIds()const;
void setSecurityGroupIds(const std::vector<std::string>& securityGroupIds);
std::string getNetworkInterfaceTrafficMode()const;
void setNetworkInterfaceTrafficMode(const std::string& networkInterfaceTrafficMode);
std::string getVSwitchId()const;
void setVSwitchId(const std::string& vSwitchId);
std::vector<std::string> getPrivateIpAddress()const;
@@ -98,8 +102,10 @@ namespace AlibabaCloud
bool visible_;
std::string resourceOwnerAccount_;
std::string ownerAccount_;
int queuePairNumber_;
long ownerId_;
std::vector<std::string> securityGroupIds_;
std::string networkInterfaceTrafficMode_;
std::string vSwitchId_;
std::vector<std::string> privateIpAddress_;
std::string primaryIpAddress_;

63
ecs/include/alibabacloud/ecs/model/DeleteDiskReplicaPairRequest.h Normal file
View File

@@ -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_ECS_MODEL_DELETEDISKREPLICAPAIRREQUEST_H_
#define ALIBABACLOUD_ECS_MODEL_DELETEDISKREPLICAPAIRREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/ecs/EcsExport.h>
namespace AlibabaCloud
{
namespace Ecs
{
namespace Model
{
class ALIBABACLOUD_ECS_EXPORT DeleteDiskReplicaPairRequest : public RpcServiceRequest
{
public:
DeleteDiskReplicaPairRequest();
~DeleteDiskReplicaPairRequest();
long getResourceOwnerId()const;
void setResourceOwnerId(long resourceOwnerId);
std::string getRegionId()const;
void setRegionId(const std::string& regionId);
std::string getResourceOwnerAccount()const;
void setResourceOwnerAccount(const std::string& resourceOwnerAccount);
std::string getOwnerAccount()const;
void setOwnerAccount(const std::string& ownerAccount);
long getOwnerId()const;
void setOwnerId(long ownerId);
std::string getReplicaPairId()const;
void setReplicaPairId(const std::string& replicaPairId);
private:
long resourceOwnerId_;
std::string regionId_;
std::string resourceOwnerAccount_;
std::string ownerAccount_;
long ownerId_;
std::string replicaPairId_;
};
}
}
}
#endif // !ALIBABACLOUD_ECS_MODEL_DELETEDISKREPLICAPAIRREQUEST_H_

49
ecs/include/alibabacloud/ecs/model/DeleteDiskReplicaPairResult.h Normal file
View File

@@ -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_ECS_MODEL_DELETEDISKREPLICAPAIRRESULT_H_
#define ALIBABACLOUD_ECS_MODEL_DELETEDISKREPLICAPAIRRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/ecs/EcsExport.h>
namespace AlibabaCloud
{
namespace Ecs
{
namespace Model
{
class ALIBABACLOUD_ECS_EXPORT DeleteDiskReplicaPairResult : public ServiceResult
{
public:
DeleteDiskReplicaPairResult();
explicit DeleteDiskReplicaPairResult(const std::string &payload);
~DeleteDiskReplicaPairResult();
protected:
void parse(const std::string &payload);
private:
};
}
}
}
#endif // !ALIBABACLOUD_ECS_MODEL_DELETEDISKREPLICAPAIRRESULT_H_

1
ecs/include/alibabacloud/ecs/model/DescribeCloudAssistantStatusResult.h
View File

@@ -39,6 +39,7 @@ namespace AlibabaCloud
std::string oSType;
long invocationCount;
std::string cloudAssistantStatus;
std::string lastHeartbeatTime;
std::string lastInvokedTime;
long activeTaskCount;
};

78
ecs/include/alibabacloud/ecs/model/DescribeDedicatedBlockStorageClustersRequest.h Normal file
View File

@@ -0,0 +1,78 @@
/*
* 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_ECS_MODEL_DESCRIBEDEDICATEDBLOCKSTORAGECLUSTERSREQUEST_H_
#define ALIBABACLOUD_ECS_MODEL_DESCRIBEDEDICATEDBLOCKSTORAGECLUSTERSREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/ecs/EcsExport.h>
namespace AlibabaCloud
{
namespace Ecs
{
namespace Model
{
class ALIBABACLOUD_ECS_EXPORT DescribeDedicatedBlockStorageClustersRequest : public RpcServiceRequest
{
public:
DescribeDedicatedBlockStorageClustersRequest();
~DescribeDedicatedBlockStorageClustersRequest();
long getResourceOwnerId()const;
void setResourceOwnerId(long resourceOwnerId);
std::string getRegionId()const;
void setRegionId(const std::string& regionId);
std::string getNextToken()const;
void setNextToken(const std::string& nextToken);
std::vector<std::string> getDedicatedBlockStorageClusterId()const;
void setDedicatedBlockStorageClusterId(const std::vector<std::string>& dedicatedBlockStorageClusterId);
std::string getResourceOwnerAccount()const;
void setResourceOwnerAccount(const std::string& resourceOwnerAccount);
std::string getOwnerAccount()const;
void setOwnerAccount(const std::string& ownerAccount);
long getOwnerId()const;
void setOwnerId(long ownerId);
std::string getZoneId()const;
void setZoneId(const std::string& zoneId);
int getMaxResults()const;
void setMaxResults(int maxResults);
std::string getCategory()const;
void setCategory(const std::string& category);
std::vector<std::string> getStatus()const;
void setStatus(const std::vector<std::string>& status);
private:
long resourceOwnerId_;
std::string regionId_;
std::string nextToken_;
std::vector<std::string> dedicatedBlockStorageClusterId_;
std::string resourceOwnerAccount_;
std::string ownerAccount_;
long ownerId_;
std::string zoneId_;
int maxResults_;
std::string category_;
std::vector<std::string> status_;
};
}
}
}
#endif // !ALIBABACLOUD_ECS_MODEL_DESCRIBEDEDICATEDBLOCKSTORAGECLUSTERSREQUEST_H_

71
ecs/include/alibabacloud/ecs/model/DescribeDedicatedBlockStorageClustersResult.h Normal file
View File

@@ -0,0 +1,71 @@
/*
* 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_ECS_MODEL_DESCRIBEDEDICATEDBLOCKSTORAGECLUSTERSRESULT_H_
#define ALIBABACLOUD_ECS_MODEL_DESCRIBEDEDICATEDBLOCKSTORAGECLUSTERSRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/ecs/EcsExport.h>
namespace AlibabaCloud
{
namespace Ecs
{
namespace Model
{
class ALIBABACLOUD_ECS_EXPORT DescribeDedicatedBlockStorageClustersResult : public ServiceResult
{
public:
struct DedicatedBlockStorageCluster
{
struct DedicatedBlockStorageClusterCapacity
{
long availableCapacity;
long totalCapacity;
};
std::string status;
std::string description;
std::string category;
std::string zoneId;
std::string dedicatedBlockStorageClusterId;
std::string performanceLevel;
std::string expiredTime;
std::string createTime;
std::string dedicatedBlockStorageClusterName;
DedicatedBlockStorageClusterCapacity dedicatedBlockStorageClusterCapacity;
};
DescribeDedicatedBlockStorageClustersResult();
explicit DescribeDedicatedBlockStorageClustersResult(const std::string &payload);
~DescribeDedicatedBlockStorageClustersResult();
std::vector<DedicatedBlockStorageCluster> getDedicatedBlockStorageClusters()const;
std::string getNextToken()const;
protected:
void parse(const std::string &payload);
private:
std::vector<DedicatedBlockStorageCluster> dedicatedBlockStorageClusters_;
std::string nextToken_;
};
}
}
}
#endif // !ALIBABACLOUD_ECS_MODEL_DESCRIBEDEDICATEDBLOCKSTORAGECLUSTERSRESULT_H_

66
ecs/include/alibabacloud/ecs/model/DescribeDiskReplicaPairsRequest.h Normal file
View File

@@ -0,0 +1,66 @@
/*
* 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_ECS_MODEL_DESCRIBEDISKREPLICAPAIRSREQUEST_H_
#define ALIBABACLOUD_ECS_MODEL_DESCRIBEDISKREPLICAPAIRSREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/ecs/EcsExport.h>
namespace AlibabaCloud
{
namespace Ecs
{
namespace Model
{
class ALIBABACLOUD_ECS_EXPORT DescribeDiskReplicaPairsRequest : public RpcServiceRequest
{
public:
DescribeDiskReplicaPairsRequest();
~DescribeDiskReplicaPairsRequest();
long getResourceOwnerId()const;
void setResourceOwnerId(long resourceOwnerId);
std::string getRegionId()const;
void setRegionId(const std::string& regionId);
std::string getNextToken()const;
void setNextToken(const std::string& nextToken);
std::string getResourceOwnerAccount()const;
void setResourceOwnerAccount(const std::string& resourceOwnerAccount);
std::string getOwnerAccount()const;
void setOwnerAccount(const std::string& ownerAccount);
long getOwnerId()const;
void setOwnerId(long ownerId);
int getMaxResults()const;
void setMaxResults(int maxResults);
private:
long resourceOwnerId_;
std::string regionId_;
std::string nextToken_;
std::string resourceOwnerAccount_;
std::string ownerAccount_;
long ownerId_;
int maxResults_;
};
}
}
}
#endif // !ALIBABACLOUD_ECS_MODEL_DESCRIBEDISKREPLICAPAIRSREQUEST_H_

64
ecs/include/alibabacloud/ecs/model/DescribeDiskReplicaPairsResult.h Normal file
View File

@@ -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_ECS_MODEL_DESCRIBEDISKREPLICAPAIRSRESULT_H_
#define ALIBABACLOUD_ECS_MODEL_DESCRIBEDISKREPLICAPAIRSRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/ecs/EcsExport.h>
namespace AlibabaCloud
{
namespace Ecs
{
namespace Model
{
class ALIBABACLOUD_ECS_EXPORT DescribeDiskReplicaPairsResult : public ServiceResult
{
public:
struct DiskReplicaPair
{
std::string status;
std::string destinationDiskId;
std::string description;
std::string pairName;
std::string destinationRegion;
std::string replicaPairId;
std::string sourceRegion;
std::string sourceDiskId;
};
DescribeDiskReplicaPairsResult();
explicit DescribeDiskReplicaPairsResult(const std::string &payload);
~DescribeDiskReplicaPairsResult();
std::string getNextToken()const;
std::vector<DiskReplicaPair> getDiskReplicaPairs()const;
protected:
void parse(const std::string &payload);
private:
std::string nextToken_;
std::vector<DiskReplicaPair> diskReplicaPairs_;
};
}
}
}
#endif // !ALIBABACLOUD_ECS_MODEL_DESCRIBEDISKREPLICAPAIRSRESULT_H_

1
ecs/include/alibabacloud/ecs/model/DescribeDisksResult.h
View File

@@ -54,6 +54,7 @@ namespace AlibabaCloud
std::string category;
std::string kMSKeyId;
std::string resourceGroupId;
std::string dedicatedBlockStorageClusterId;
int size;
bool encrypted;
bool deleteAutoSnapshot;

6
ecs/include/alibabacloud/ecs/model/DescribeInstanceHistoryEventsRequest.h
View File

@@ -53,6 +53,8 @@ namespace AlibabaCloud
void setInstanceEventCycleStatus(const std::vector<std::string>& instanceEventCycleStatus);
std::string getEventPublishTimeEnd()const;
void setEventPublishTimeEnd(const std::string& eventPublishTimeEnd);
std::vector<std::string> getResourceId()const;
void setResourceId(const std::vector<std::string>& resourceId);
std::vector<std::string> getInstanceEventType()const;
void setInstanceEventType(const std::vector<std::string>& instanceEventType);
std::string getResourceOwnerAccount()const;
@@ -63,6 +65,8 @@ namespace AlibabaCloud
void setNotBeforeStart(const std::string& notBeforeStart);
long getOwnerId()const;
void setOwnerId(long ownerId);
std::string getResourceType()const;
void setResourceType(const std::string& resourceType);
std::string getEventPublishTimeStart()const;
void setEventPublishTimeStart(const std::string& eventPublishTimeStart);
std::string getInstanceId()const;
@@ -82,11 +86,13 @@ namespace AlibabaCloud
int pageSize_;
std::vector<std::string> instanceEventCycleStatus_;
std::string eventPublishTimeEnd_;
std::vector<std::string> resourceId_;
std::vector<std::string> instanceEventType_;
std::string resourceOwnerAccount_;
std::string ownerAccount_;
std::string notBeforeStart_;
long ownerId_;
std::string resourceType_;
std::string eventPublishTimeStart_;
std::string instanceId_;
std::string notBeforeEnd_;

1
ecs/include/alibabacloud/ecs/model/DescribeInstanceHistoryEventsResult.h
View File

@@ -66,6 +66,7 @@ namespace AlibabaCloud
std::string impactLevel;
ExtendedAttribute extendedAttribute;
std::string eventId;
std::string resourceType;
std::string notBefore;
std::string reason;
};

3
ecs/include/alibabacloud/ecs/model/DescribeInstanceTypesResult.h
View File

@@ -35,12 +35,14 @@ namespace AlibabaCloud
struct InstanceType
{
long instancePpsTx;
std::string nvmeSupport;
int primaryEniQueueNumber;
long localStorageCapacity;
int totalEniQueueQuantity;
bool eniTrunkSupported;
std::string instanceTypeFamily;
long instancePpsRx;
int eriQuantity;
int instanceBandwidthRx;
int instanceBandwidthTx;
int localStorageAmount;
@@ -57,6 +59,7 @@ namespace AlibabaCloud
int eniQuantity;
int gPUAmount;
int diskQuantity;
int queuePairNumber;
int baselineCredit;
std::string instanceFamilyLevel;
int eniPrivateIpAddressQuantity;

2
ecs/include/alibabacloud/ecs/model/DescribeInvocationsResult.h
View File

@@ -39,6 +39,7 @@ namespace AlibabaCloud
int dropped;
std::string invocationStatus;
std::string instanceId;
bool timed;
std::string instanceInvokeStatus;
long exitCode;
std::string errorInfo;
@@ -56,6 +57,7 @@ namespace AlibabaCloud
bool timed;
std::vector<Invocation::InvokeInstance> invokeInstances;
std::string commandContent;
std::string repeatMode;
std::string invokeStatus;
std::string commandType;
std::string username;

36
ecs/include/alibabacloud/ecs/model/DescribeNetworkInterfaceAttributeResult.h
View File

@@ -69,55 +69,59 @@ namespace AlibabaCloud
DescribeNetworkInterfaceAttributeResult();
explicit DescribeNetworkInterfaceAttributeResult(const std::string &payload);
~DescribeNetworkInterfaceAttributeResult();
std::string getStatus()const;
std::string getPrivateIpAddress()const;
std::string getDescription()const;
std::string getZoneId()const;
std::string getResourceGroupId()const;
bool getServiceManaged()const;
Attachment getAttachment()const;
std::string getNetworkInterfaceId()const;
std::vector<Ipv6Set> getIpv6Sets()const;
std::string getOwnerId()const;
AssociatedPublicIp getAssociatedPublicIp()const;
std::vector<Tag> getTags()const;
std::string getStatus()const;
std::string getNetworkInterfaceTrafficMode()const;
std::string getZoneId()const;
std::string getInstanceId()const;
std::string getVSwitchId()const;
std::string getNetworkInterfaceName()const;
Attachment getAttachment()const;
std::string getNetworkInterfaceId()const;
std::string getMacAddress()const;
std::vector<std::string> getSecurityGroupIds()const;
long getServiceID()const;
std::string getType()const;
std::vector<Ipv6Set> getIpv6Sets()const;
int getQueueNumber()const;
int getQueuePairNumber()const;
std::string getVpcId()const;
std::string getOwnerId()const;
AssociatedPublicIp getAssociatedPublicIp()const;
std::string getCreationTime()const;
std::vector<Tag> getTags()const;
std::vector<PrivateIpSet> getPrivateIpSets()const;
protected:
void parse(const std::string &payload);
private:
std::string status_;
std::string privateIpAddress_;
std::string description_;
std::string zoneId_;
std::string resourceGroupId_;
bool serviceManaged_;
Attachment attachment_;
std::string networkInterfaceId_;
std::vector<Ipv6Set> ipv6Sets_;
std::string ownerId_;
AssociatedPublicIp associatedPublicIp_;
std::vector<Tag> tags_;
std::string status_;
std::string networkInterfaceTrafficMode_;
std::string zoneId_;
std::string instanceId_;
std::string vSwitchId_;
std::string networkInterfaceName_;
Attachment attachment_;
std::string networkInterfaceId_;
std::string macAddress_;
std::vector<std::string> securityGroupIds_;
long serviceID_;
std::string type_;
std::vector<Ipv6Set> ipv6Sets_;
int queueNumber_;
int queuePairNumber_;
std::string vpcId_;
std::string ownerId_;
AssociatedPublicIp associatedPublicIp_;
std::string creationTime_;
std::vector<Tag> tags_;
std::vector<PrivateIpSet> privateIpSets_;
};

18
ecs/include/alibabacloud/ecs/model/DescribeNetworkInterfacesResult.h
View File

@@ -65,28 +65,30 @@ namespace AlibabaCloud
std::string tagKey;
std::string tagValue;
};
std::string status;
std::string privateIpAddress;
std::string description;
std::string zoneId;
std::string resourceGroupId;
bool serviceManaged;
Attachment attachment;
std::string networkInterfaceId;
std::vector<NetworkInterfaceSet::Ipv6Set> ipv6Sets;
std::string ownerId;
AssociatedPublicIp associatedPublicIp;
std::vector<NetworkInterfaceSet::Tag> tags;
std::string status;
std::string networkInterfaceTrafficMode;
std::string zoneId;
std::string instanceId;
std::string vSwitchId;
std::string networkInterfaceName;
Attachment attachment;
std::string networkInterfaceId;
std::string macAddress;
std::vector<std::string> securityGroupIds;
long serviceID;
std::string type;
std::vector<NetworkInterfaceSet::Ipv6Set> ipv6Sets;
int queueNumber;
int queuePairNumber;
std::string vpcId;
std::string ownerId;
AssociatedPublicIp associatedPublicIp;
std::string creationTime;
std::vector<NetworkInterfaceSet::Tag> tags;
std::vector<NetworkInterfaceSet::PrivateIpSet> privateIpSets;
};

3
ecs/include/alibabacloud/ecs/model/InvokeCommandRequest.h
View File

@@ -43,6 +43,8 @@ namespace AlibabaCloud
void setFrequency(const std::string& frequency);
std::string getRegionId()const;
void setRegionId(const std::string& regionId);
std::string getRepeatMode()const;
void setRepeatMode(const std::string& repeatMode);
std::string getWindowsPasswordName()const;
void setWindowsPasswordName(const std::string& windowsPasswordName);
bool getTimed()const;
@@ -65,6 +67,7 @@ namespace AlibabaCloud
std::string commandId_;
std::string frequency_;
std::string regionId_;
std::string repeatMode_;
std::string windowsPasswordName_;
bool timed_;
std::string resourceOwnerAccount_;

3
ecs/include/alibabacloud/ecs/model/ModifyDiskAttributeRequest.h
View File

@@ -43,6 +43,8 @@ namespace AlibabaCloud
void setDiskName(const std::string& diskName);
bool getDeleteAutoSnapshot()const;
void setDeleteAutoSnapshot(bool deleteAutoSnapshot);
std::string getRegionId()const;
void setRegionId(const std::string& regionId);
std::vector<std::string> getDiskIds()const;
void setDiskIds(const std::vector<std::string>& diskIds);
std::string getDiskId()const;
@@ -63,6 +65,7 @@ namespace AlibabaCloud
std::string description_;
std::string diskName_;
bool deleteAutoSnapshot_;
std::string regionId_;
std::vector<std::string> diskIds_;
std::string diskId_;
bool deleteWithInstance_;

3
ecs/include/alibabacloud/ecs/model/RunCommandRequest.h
View File

@@ -53,6 +53,8 @@ namespace AlibabaCloud
void setRegionId(const std::string& regionId);
std::string getContentEncoding()const;
void setContentEncoding(const std::string& contentEncoding);
std::string getRepeatMode()const;
void setRepeatMode(const std::string& repeatMode);
std::string getWindowsPasswordName()const;
void setWindowsPasswordName(const std::string& windowsPasswordName);
bool getKeepCommand()const;
@@ -86,6 +88,7 @@ namespace AlibabaCloud
std::string frequency_;
std::string regionId_;
std::string contentEncoding_;
std::string repeatMode_;
std::string windowsPasswordName_;
bool keepCommand_;
bool timed_;

63
ecs/include/alibabacloud/ecs/model/StartDiskReplicaPairRequest.h Normal file
View File

@@ -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_ECS_MODEL_STARTDISKREPLICAPAIRREQUEST_H_
#define ALIBABACLOUD_ECS_MODEL_STARTDISKREPLICAPAIRREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/ecs/EcsExport.h>
namespace AlibabaCloud
{
namespace Ecs
{
namespace Model
{
class ALIBABACLOUD_ECS_EXPORT StartDiskReplicaPairRequest : public RpcServiceRequest
{
public:
StartDiskReplicaPairRequest();
~StartDiskReplicaPairRequest();
long getResourceOwnerId()const;
void setResourceOwnerId(long resourceOwnerId);
std::string getRegionId()const;
void setRegionId(const std::string& regionId);
std::string getResourceOwnerAccount()const;
void setResourceOwnerAccount(const std::string& resourceOwnerAccount);
std::string getOwnerAccount()const;
void setOwnerAccount(const std::string& ownerAccount);
long getOwnerId()const;
void setOwnerId(long ownerId);
std::string getReplicaPairId()const;
void setReplicaPairId(const std::string& replicaPairId);
private:
long resourceOwnerId_;
std::string regionId_;
std::string resourceOwnerAccount_;
std::string ownerAccount_;
long ownerId_;
std::string replicaPairId_;
};
}
}
}
#endif // !ALIBABACLOUD_ECS_MODEL_STARTDISKREPLICAPAIRREQUEST_H_

49
ecs/include/alibabacloud/ecs/model/StartDiskReplicaPairResult.h Normal file
View File

@@ -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_ECS_MODEL_STARTDISKREPLICAPAIRRESULT_H_
#define ALIBABACLOUD_ECS_MODEL_STARTDISKREPLICAPAIRRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/ecs/EcsExport.h>
namespace AlibabaCloud
{
namespace Ecs
{
namespace Model
{
class ALIBABACLOUD_ECS_EXPORT StartDiskReplicaPairResult : public ServiceResult
{
public:
StartDiskReplicaPairResult();
explicit StartDiskReplicaPairResult(const std::string &payload);
~StartDiskReplicaPairResult();
protected:
void parse(const std::string &payload);
private:
};
}
}
}
#endif // !ALIBABACLOUD_ECS_MODEL_STARTDISKREPLICAPAIRRESULT_H_

63
ecs/include/alibabacloud/ecs/model/StopDiskReplicaPairRequest.h Normal file
View File

@@ -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_ECS_MODEL_STOPDISKREPLICAPAIRREQUEST_H_
#define ALIBABACLOUD_ECS_MODEL_STOPDISKREPLICAPAIRREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/ecs/EcsExport.h>
namespace AlibabaCloud
{
namespace Ecs
{
namespace Model
{
class ALIBABACLOUD_ECS_EXPORT StopDiskReplicaPairRequest : public RpcServiceRequest
{
public:
StopDiskReplicaPairRequest();
~StopDiskReplicaPairRequest();
long getResourceOwnerId()const;
void setResourceOwnerId(long resourceOwnerId);
std::string getRegionId()const;
void setRegionId(const std::string& regionId);
std::string getResourceOwnerAccount()const;
void setResourceOwnerAccount(const std::string& resourceOwnerAccount);
std::string getOwnerAccount()const;
void setOwnerAccount(const std::string& ownerAccount);
long getOwnerId()const;
void setOwnerId(long ownerId);
std::string getReplicaPairId()const;
void setReplicaPairId(const std::string& replicaPairId);
private:
long resourceOwnerId_;
std::string regionId_;
std::string resourceOwnerAccount_;
std::string ownerAccount_;
long ownerId_;
std::string replicaPairId_;
};
}
}
}
#endif // !ALIBABACLOUD_ECS_MODEL_STOPDISKREPLICAPAIRREQUEST_H_

49
ecs/include/alibabacloud/ecs/model/StopDiskReplicaPairResult.h Normal file
View File

@@ -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_ECS_MODEL_STOPDISKREPLICAPAIRRESULT_H_
#define ALIBABACLOUD_ECS_MODEL_STOPDISKREPLICAPAIRRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/ecs/EcsExport.h>
namespace AlibabaCloud
{
namespace Ecs
{
namespace Model
{
class ALIBABACLOUD_ECS_EXPORT StopDiskReplicaPairResult : public ServiceResult
{
public:
StopDiskReplicaPairResult();
explicit StopDiskReplicaPairResult(const std::string &payload);
~StopDiskReplicaPairResult();
protected:
void parse(const std::string &payload);
private:
};
}
}
}
#endif // !ALIBABACLOUD_ECS_MODEL_STOPDISKREPLICAPAIRRESULT_H_

252
ecs/src/EcsClient.cc
View File

@@ -1275,6 +1275,42 @@ EcsClient::CreateCommandOutcomeCallable EcsClient::createCommandCallable(const C
return task->get_future();
}
EcsClient::CreateDedicatedBlockStorageClusterOutcome EcsClient::createDedicatedBlockStorageCluster(const CreateDedicatedBlockStorageClusterRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return CreateDedicatedBlockStorageClusterOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return CreateDedicatedBlockStorageClusterOutcome(CreateDedicatedBlockStorageClusterResult(outcome.result()));
else
return CreateDedicatedBlockStorageClusterOutcome(outcome.error());
}
void EcsClient::createDedicatedBlockStorageClusterAsync(const CreateDedicatedBlockStorageClusterRequest& request, const CreateDedicatedBlockStorageClusterAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, createDedicatedBlockStorageCluster(request), context);
};
asyncExecute(new Runnable(fn));
}
EcsClient::CreateDedicatedBlockStorageClusterOutcomeCallable EcsClient::createDedicatedBlockStorageClusterCallable(const CreateDedicatedBlockStorageClusterRequest &request) const
{
auto task = std::make_shared<std::packaged_task<CreateDedicatedBlockStorageClusterOutcome()>>(
[this, request]()
{
return this->createDedicatedBlockStorageCluster(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
EcsClient::CreateDedicatedHostClusterOutcome EcsClient::createDedicatedHostCluster(const CreateDedicatedHostClusterRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -1419,6 +1455,42 @@ EcsClient::CreateDiskOutcomeCallable EcsClient::createDiskCallable(const CreateD
return task->get_future();
}
EcsClient::CreateDiskReplicaPairOutcome EcsClient::createDiskReplicaPair(const CreateDiskReplicaPairRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return CreateDiskReplicaPairOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return CreateDiskReplicaPairOutcome(CreateDiskReplicaPairResult(outcome.result()));
else
return CreateDiskReplicaPairOutcome(outcome.error());
}
void EcsClient::createDiskReplicaPairAsync(const CreateDiskReplicaPairRequest& request, const CreateDiskReplicaPairAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, createDiskReplicaPair(request), context);
};
asyncExecute(new Runnable(fn));
}
EcsClient::CreateDiskReplicaPairOutcomeCallable EcsClient::createDiskReplicaPairCallable(const CreateDiskReplicaPairRequest &request) const
{
auto task = std::make_shared<std::packaged_task<CreateDiskReplicaPairOutcome()>>(
[this, request]()
{
return this->createDiskReplicaPair(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
EcsClient::CreateElasticityAssuranceOutcome EcsClient::createElasticityAssurance(const CreateElasticityAssuranceRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -2679,6 +2751,42 @@ EcsClient::DeleteDiskOutcomeCallable EcsClient::deleteDiskCallable(const DeleteD
return task->get_future();
}
EcsClient::DeleteDiskReplicaPairOutcome EcsClient::deleteDiskReplicaPair(const DeleteDiskReplicaPairRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return DeleteDiskReplicaPairOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return DeleteDiskReplicaPairOutcome(DeleteDiskReplicaPairResult(outcome.result()));
else
return DeleteDiskReplicaPairOutcome(outcome.error());
}
void EcsClient::deleteDiskReplicaPairAsync(const DeleteDiskReplicaPairRequest& request, const DeleteDiskReplicaPairAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, deleteDiskReplicaPair(request), context);
};
asyncExecute(new Runnable(fn));
}
EcsClient::DeleteDiskReplicaPairOutcomeCallable EcsClient::deleteDiskReplicaPairCallable(const DeleteDiskReplicaPairRequest &request) const
{
auto task = std::make_shared<std::packaged_task<DeleteDiskReplicaPairOutcome()>>(
[this, request]()
{
return this->deleteDiskReplicaPair(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
EcsClient::DeleteForwardEntryOutcome EcsClient::deleteForwardEntry(const DeleteForwardEntryRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -4155,6 +4263,42 @@ EcsClient::DescribeCommandsOutcomeCallable EcsClient::describeCommandsCallable(c
return task->get_future();
}
EcsClient::DescribeDedicatedBlockStorageClustersOutcome EcsClient::describeDedicatedBlockStorageClusters(const DescribeDedicatedBlockStorageClustersRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return DescribeDedicatedBlockStorageClustersOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return DescribeDedicatedBlockStorageClustersOutcome(DescribeDedicatedBlockStorageClustersResult(outcome.result()));
else
return DescribeDedicatedBlockStorageClustersOutcome(outcome.error());
}
void EcsClient::describeDedicatedBlockStorageClustersAsync(const DescribeDedicatedBlockStorageClustersRequest& request, const DescribeDedicatedBlockStorageClustersAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, describeDedicatedBlockStorageClusters(request), context);
};
asyncExecute(new Runnable(fn));
}
EcsClient::DescribeDedicatedBlockStorageClustersOutcomeCallable EcsClient::describeDedicatedBlockStorageClustersCallable(const DescribeDedicatedBlockStorageClustersRequest &request) const
{
auto task = std::make_shared<std::packaged_task<DescribeDedicatedBlockStorageClustersOutcome()>>(
[this, request]()
{
return this->describeDedicatedBlockStorageClusters(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
EcsClient::DescribeDedicatedHostAutoRenewOutcome EcsClient::describeDedicatedHostAutoRenew(const DescribeDedicatedHostAutoRenewRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -4443,6 +4587,42 @@ EcsClient::DescribeDiskMonitorDataOutcomeCallable EcsClient::describeDiskMonitor
return task->get_future();
}
EcsClient::DescribeDiskReplicaPairsOutcome EcsClient::describeDiskReplicaPairs(const DescribeDiskReplicaPairsRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return DescribeDiskReplicaPairsOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return DescribeDiskReplicaPairsOutcome(DescribeDiskReplicaPairsResult(outcome.result()));
else
return DescribeDiskReplicaPairsOutcome(outcome.error());
}
void EcsClient::describeDiskReplicaPairsAsync(const DescribeDiskReplicaPairsRequest& request, const DescribeDiskReplicaPairsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, describeDiskReplicaPairs(request), context);
};
asyncExecute(new Runnable(fn));
}
EcsClient::DescribeDiskReplicaPairsOutcomeCallable EcsClient::describeDiskReplicaPairsCallable(const DescribeDiskReplicaPairsRequest &request) const
{
auto task = std::make_shared<std::packaged_task<DescribeDiskReplicaPairsOutcome()>>(
[this, request]()
{
return this->describeDiskReplicaPairs(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
EcsClient::DescribeDisksOutcome EcsClient::describeDisks(const DescribeDisksRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -11247,6 +11427,42 @@ EcsClient::SendFileOutcomeCallable EcsClient::sendFileCallable(const SendFileReq
return task->get_future();
}
EcsClient::StartDiskReplicaPairOutcome EcsClient::startDiskReplicaPair(const StartDiskReplicaPairRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return StartDiskReplicaPairOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return StartDiskReplicaPairOutcome(StartDiskReplicaPairResult(outcome.result()));
else
return StartDiskReplicaPairOutcome(outcome.error());
}
void EcsClient::startDiskReplicaPairAsync(const StartDiskReplicaPairRequest& request, const StartDiskReplicaPairAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, startDiskReplicaPair(request), context);
};
asyncExecute(new Runnable(fn));
}
EcsClient::StartDiskReplicaPairOutcomeCallable EcsClient::startDiskReplicaPairCallable(const StartDiskReplicaPairRequest &request) const
{
auto task = std::make_shared<std::packaged_task<StartDiskReplicaPairOutcome()>>(
[this, request]()
{
return this->startDiskReplicaPair(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
EcsClient::StartElasticityAssuranceOutcome EcsClient::startElasticityAssurance(const StartElasticityAssuranceRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -11391,6 +11607,42 @@ EcsClient::StartInstancesOutcomeCallable EcsClient::startInstancesCallable(const
return task->get_future();
}
EcsClient::StopDiskReplicaPairOutcome EcsClient::stopDiskReplicaPair(const StopDiskReplicaPairRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return StopDiskReplicaPairOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return StopDiskReplicaPairOutcome(StopDiskReplicaPairResult(outcome.result()));
else
return StopDiskReplicaPairOutcome(outcome.error());
}
void EcsClient::stopDiskReplicaPairAsync(const StopDiskReplicaPairRequest& request, const StopDiskReplicaPairAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, stopDiskReplicaPair(request), context);
};
asyncExecute(new Runnable(fn));
}
EcsClient::StopDiskReplicaPairOutcomeCallable EcsClient::stopDiskReplicaPairCallable(const StopDiskReplicaPairRequest &request) const
{
auto task = std::make_shared<std::packaged_task<StopDiskReplicaPairOutcome()>>(
[this, request]()
{
return this->stopDiskReplicaPair(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
EcsClient::StopInstanceOutcome EcsClient::stopInstance(const StopInstanceRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();

11
ecs/src/model/AcceptInquiredSystemEventRequest.cc
View File

@@ -93,3 +93,14 @@ void AcceptInquiredSystemEventRequest::setOwnerId(long ownerId)
setParameter("OwnerId", std::to_string(ownerId));
}
std::string AcceptInquiredSystemEventRequest::getChoice()const
{
return choice_;
}
void AcceptInquiredSystemEventRequest::setChoice(const std::string& choice)
{
choice_ = choice;
setParameter("Choice", choice);
}

194
ecs/src/model/CreateDedicatedBlockStorageClusterRequest.cc Normal file
View File

@@ -0,0 +1,194 @@
/*
* 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 <alibabacloud/ecs/model/CreateDedicatedBlockStorageClusterRequest.h>
using AlibabaCloud::Ecs::Model::CreateDedicatedBlockStorageClusterRequest;
CreateDedicatedBlockStorageClusterRequest::CreateDedicatedBlockStorageClusterRequest() :
RpcServiceRequest("ecs", "2014-05-26", "CreateDedicatedBlockStorageCluster")
{
setMethod(HttpRequest::Method::Post);
}
CreateDedicatedBlockStorageClusterRequest::~CreateDedicatedBlockStorageClusterRequest()
{}
long CreateDedicatedBlockStorageClusterRequest::getResourceOwnerId()const
{
return resourceOwnerId_;
}
void CreateDedicatedBlockStorageClusterRequest::setResourceOwnerId(long resourceOwnerId)
{
resourceOwnerId_ = resourceOwnerId;
setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
}
std::string CreateDedicatedBlockStorageClusterRequest::getDedicatedBlockStorageClusterName()const
{
return dedicatedBlockStorageClusterName_;
}
void CreateDedicatedBlockStorageClusterRequest::setDedicatedBlockStorageClusterName(const std::string& dedicatedBlockStorageClusterName)
{
dedicatedBlockStorageClusterName_ = dedicatedBlockStorageClusterName;
setParameter("DedicatedBlockStorageClusterName", dedicatedBlockStorageClusterName);
}
std::string CreateDedicatedBlockStorageClusterRequest::getClientToken()const
{
return clientToken_;
}
void CreateDedicatedBlockStorageClusterRequest::setClientToken(const std::string& clientToken)
{
clientToken_ = clientToken;
setParameter("ClientToken", clientToken);
}
std::string CreateDedicatedBlockStorageClusterRequest::getDescription()const
{
return description_;
}
void CreateDedicatedBlockStorageClusterRequest::setDescription(const std::string& description)
{
description_ = description;
setParameter("Description", description);
}
int CreateDedicatedBlockStorageClusterRequest::getCapacity()const
{
return capacity_;
}
void CreateDedicatedBlockStorageClusterRequest::setCapacity(int capacity)
{
capacity_ = capacity;
setParameter("Capacity", std::to_string(capacity));
}
std::string CreateDedicatedBlockStorageClusterRequest::getRegionId()const
{
return regionId_;
}
void CreateDedicatedBlockStorageClusterRequest::setRegionId(const std::string& regionId)
{
regionId_ = regionId;
setParameter("RegionId", regionId);
}
int CreateDedicatedBlockStorageClusterRequest::getPeriod()const
{
return period_;
}
void CreateDedicatedBlockStorageClusterRequest::setPeriod(int period)
{
period_ = period;
setParameter("Period", std::to_string(period));
}
std::string CreateDedicatedBlockStorageClusterRequest::getFromApp()const
{
return fromApp_;
}
void CreateDedicatedBlockStorageClusterRequest::setFromApp(const std::string& fromApp)
{
fromApp_ = fromApp;
setParameter("FromApp", fromApp);
}
std::string CreateDedicatedBlockStorageClusterRequest::getResourceOwnerAccount()const
{
return resourceOwnerAccount_;
}
void CreateDedicatedBlockStorageClusterRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
{
resourceOwnerAccount_ = resourceOwnerAccount;
setParameter("ResourceOwnerAccount", resourceOwnerAccount);
}
std::string CreateDedicatedBlockStorageClusterRequest::getPerformanceLevel()const
{
return performanceLevel_;
}
void CreateDedicatedBlockStorageClusterRequest::setPerformanceLevel(const std::string& performanceLevel)
{
performanceLevel_ = performanceLevel;
setParameter("PerformanceLevel", performanceLevel);
}
std::string CreateDedicatedBlockStorageClusterRequest::getOwnerAccount()const
{
return ownerAccount_;
}
void CreateDedicatedBlockStorageClusterRequest::setOwnerAccount(const std::string& ownerAccount)
{
ownerAccount_ = ownerAccount;
setParameter("OwnerAccount", ownerAccount);
}
long CreateDedicatedBlockStorageClusterRequest::getOwnerId()const
{
return ownerId_;
}
void CreateDedicatedBlockStorageClusterRequest::setOwnerId(long ownerId)
{
ownerId_ = ownerId;
setParameter("OwnerId", std::to_string(ownerId));
}
std::string CreateDedicatedBlockStorageClusterRequest::getPeriodUnit()const
{
return periodUnit_;
}
void CreateDedicatedBlockStorageClusterRequest::setPeriodUnit(const std::string& periodUnit)
{
periodUnit_ = periodUnit;
setParameter("PeriodUnit", periodUnit);
}
std::string CreateDedicatedBlockStorageClusterRequest::getZoneId()const
{
return zoneId_;
}
void CreateDedicatedBlockStorageClusterRequest::setZoneId(const std::string& zoneId)
{
zoneId_ = zoneId;
setParameter("ZoneId", zoneId);
}
std::string CreateDedicatedBlockStorageClusterRequest::getCategory()const
{
return category_;
}
void CreateDedicatedBlockStorageClusterRequest::setCategory(const std::string& category)
{
category_ = category;
setParameter("Category", category);
}

58
ecs/src/model/CreateDedicatedBlockStorageClusterResult.cc Normal file
View File

@@ -0,0 +1,58 @@
/*
* 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 <alibabacloud/ecs/model/CreateDedicatedBlockStorageClusterResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Ecs;
using namespace AlibabaCloud::Ecs::Model;
CreateDedicatedBlockStorageClusterResult::CreateDedicatedBlockStorageClusterResult() :
ServiceResult()
{}
CreateDedicatedBlockStorageClusterResult::CreateDedicatedBlockStorageClusterResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
CreateDedicatedBlockStorageClusterResult::~CreateDedicatedBlockStorageClusterResult()
{}
void CreateDedicatedBlockStorageClusterResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
if(!value["DedicatedBlockStorageClusterOrderId"].isNull())
dedicatedBlockStorageClusterOrderId_ = value["DedicatedBlockStorageClusterOrderId"].asString();
if(!value["DedicatedBlockStorageClusterId"].isNull())
dedicatedBlockStorageClusterId_ = value["DedicatedBlockStorageClusterId"].asString();
}
std::string CreateDedicatedBlockStorageClusterResult::getDedicatedBlockStorageClusterOrderId()const
{
return dedicatedBlockStorageClusterOrderId_;
}
std::string CreateDedicatedBlockStorageClusterResult::getDedicatedBlockStorageClusterId()const
{
return dedicatedBlockStorageClusterId_;
}

150
ecs/src/model/CreateDiskReplicaPairRequest.cc Normal file
View File

@@ -0,0 +1,150 @@
/*
* 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 <alibabacloud/ecs/model/CreateDiskReplicaPairRequest.h>
using AlibabaCloud::Ecs::Model::CreateDiskReplicaPairRequest;
CreateDiskReplicaPairRequest::CreateDiskReplicaPairRequest() :
RpcServiceRequest("ecs", "2014-05-26", "CreateDiskReplicaPair")
{
setMethod(HttpRequest::Method::Post);
}
CreateDiskReplicaPairRequest::~CreateDiskReplicaPairRequest()
{}
long CreateDiskReplicaPairRequest::getResourceOwnerId()const
{
return resourceOwnerId_;
}
void CreateDiskReplicaPairRequest::setResourceOwnerId(long resourceOwnerId)
{
resourceOwnerId_ = resourceOwnerId;
setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
}
std::string CreateDiskReplicaPairRequest::getPairName()const
{
return pairName_;
}
void CreateDiskReplicaPairRequest::setPairName(const std::string& pairName)
{
pairName_ = pairName;
setParameter("PairName", pairName);
}
std::string CreateDiskReplicaPairRequest::getDestinationRegionId()const
{
return destinationRegionId_;
}
void CreateDiskReplicaPairRequest::setDestinationRegionId(const std::string& destinationRegionId)
{
destinationRegionId_ = destinationRegionId;
setParameter("DestinationRegionId", destinationRegionId);
}
std::string CreateDiskReplicaPairRequest::getDescription()const
{
return description_;
}
void CreateDiskReplicaPairRequest::setDescription(const std::string& description)
{
description_ = description;
setParameter("Description", description);
}
std::string CreateDiskReplicaPairRequest::getRegionId()const
{
return regionId_;
}
void CreateDiskReplicaPairRequest::setRegionId(const std::string& regionId)
{
regionId_ = regionId;
setParameter("RegionId", regionId);
}
std::string CreateDiskReplicaPairRequest::getDiskId()const
{
return diskId_;
}
void CreateDiskReplicaPairRequest::setDiskId(const std::string& diskId)
{
diskId_ = diskId;
setParameter("DiskId", diskId);
}
int CreateDiskReplicaPairRequest::getAsyncCycle()const
{
return asyncCycle_;
}
void CreateDiskReplicaPairRequest::setAsyncCycle(int asyncCycle)
{
asyncCycle_ = asyncCycle;
setParameter("AsyncCycle", std::to_string(asyncCycle));
}
std::string CreateDiskReplicaPairRequest::getResourceOwnerAccount()const
{
return resourceOwnerAccount_;
}
void CreateDiskReplicaPairRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
{
resourceOwnerAccount_ = resourceOwnerAccount;
setParameter("ResourceOwnerAccount", resourceOwnerAccount);
}
std::string CreateDiskReplicaPairRequest::getOwnerAccount()const
{
return ownerAccount_;
}
void CreateDiskReplicaPairRequest::setOwnerAccount(const std::string& ownerAccount)
{
ownerAccount_ = ownerAccount;
setParameter("OwnerAccount", ownerAccount);
}
long CreateDiskReplicaPairRequest::getOwnerId()const
{
return ownerId_;
}
void CreateDiskReplicaPairRequest::setOwnerId(long ownerId)
{
ownerId_ = ownerId;
setParameter("OwnerId", std::to_string(ownerId));
}
std::string CreateDiskReplicaPairRequest::getDestinationDiskId()const
{
return destinationDiskId_;
}
void CreateDiskReplicaPairRequest::setDestinationDiskId(const std::string& destinationDiskId)
{
destinationDiskId_ = destinationDiskId;
setParameter("DestinationDiskId", destinationDiskId);
}

51
ecs/src/model/CreateDiskReplicaPairResult.cc Normal file
View File

@@ -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 <alibabacloud/ecs/model/CreateDiskReplicaPairResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Ecs;
using namespace AlibabaCloud::Ecs::Model;
CreateDiskReplicaPairResult::CreateDiskReplicaPairResult() :
ServiceResult()
{}
CreateDiskReplicaPairResult::CreateDiskReplicaPairResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
CreateDiskReplicaPairResult::~CreateDiskReplicaPairResult()
{}
void CreateDiskReplicaPairResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
if(!value["PairId"].isNull())
pairId_ = value["PairId"].asString();
}
std::string CreateDiskReplicaPairResult::getPairId()const
{
return pairId_;
}

11
ecs/src/model/CreateDiskRequest.cc
View File

@@ -181,6 +181,17 @@ void CreateDiskRequest::setAdvancedFeatures(const std::string& advancedFeatures)
setParameter("AdvancedFeatures", advancedFeatures);
}
std::string CreateDiskRequest::getDedicatedBlockStorageClusterId()const
{
return dedicatedBlockStorageClusterId_;
}
void CreateDiskRequest::setDedicatedBlockStorageClusterId(const std::string& dedicatedBlockStorageClusterId)
{
dedicatedBlockStorageClusterId_ = dedicatedBlockStorageClusterId;
setParameter("DedicatedBlockStorageClusterId", dedicatedBlockStorageClusterId);
}
std::string CreateDiskRequest::getResourceOwnerAccount()const
{
return resourceOwnerAccount_;

22
ecs/src/model/CreateNetworkInterfaceRequest.cc
View File

@@ -197,6 +197,17 @@ void CreateNetworkInterfaceRequest::setOwnerAccount(const std::string& ownerAcco
setParameter("OwnerAccount", ownerAccount);
}
int CreateNetworkInterfaceRequest::getQueuePairNumber()const
{
return queuePairNumber_;
}
void CreateNetworkInterfaceRequest::setQueuePairNumber(int queuePairNumber)
{
queuePairNumber_ = queuePairNumber;
setParameter("QueuePairNumber", std::to_string(queuePairNumber));
}
long CreateNetworkInterfaceRequest::getOwnerId()const
{
return ownerId_;
@@ -221,6 +232,17 @@ void CreateNetworkInterfaceRequest::setSecurityGroupIds(const std::vector<std::s
}
}
std::string CreateNetworkInterfaceRequest::getNetworkInterfaceTrafficMode()const
{
return networkInterfaceTrafficMode_;
}
void CreateNetworkInterfaceRequest::setNetworkInterfaceTrafficMode(const std::string& networkInterfaceTrafficMode)
{
networkInterfaceTrafficMode_ = networkInterfaceTrafficMode;
setParameter("NetworkInterfaceTrafficMode", networkInterfaceTrafficMode);
}
std::string CreateNetworkInterfaceRequest::getVSwitchId()const
{
return vSwitchId_;

95
ecs/src/model/DeleteDiskReplicaPairRequest.cc Normal file
View File

@@ -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 <alibabacloud/ecs/model/DeleteDiskReplicaPairRequest.h>
using AlibabaCloud::Ecs::Model::DeleteDiskReplicaPairRequest;
DeleteDiskReplicaPairRequest::DeleteDiskReplicaPairRequest() :
RpcServiceRequest("ecs", "2014-05-26", "DeleteDiskReplicaPair")
{
setMethod(HttpRequest::Method::Post);
}
DeleteDiskReplicaPairRequest::~DeleteDiskReplicaPairRequest()
{}
long DeleteDiskReplicaPairRequest::getResourceOwnerId()const
{
return resourceOwnerId_;
}
void DeleteDiskReplicaPairRequest::setResourceOwnerId(long resourceOwnerId)
{
resourceOwnerId_ = resourceOwnerId;
setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
}
std::string DeleteDiskReplicaPairRequest::getRegionId()const
{
return regionId_;
}
void DeleteDiskReplicaPairRequest::setRegionId(const std::string& regionId)
{
regionId_ = regionId;
setParameter("RegionId", regionId);
}
std::string DeleteDiskReplicaPairRequest::getResourceOwnerAccount()const
{
return resourceOwnerAccount_;
}
void DeleteDiskReplicaPairRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
{
resourceOwnerAccount_ = resourceOwnerAccount;
setParameter("ResourceOwnerAccount", resourceOwnerAccount);
}
std::string DeleteDiskReplicaPairRequest::getOwnerAccount()const
{
return ownerAccount_;
}
void DeleteDiskReplicaPairRequest::setOwnerAccount(const std::string& ownerAccount)
{
ownerAccount_ = ownerAccount;
setParameter("OwnerAccount", ownerAccount);
}
long DeleteDiskReplicaPairRequest::getOwnerId()const
{
return ownerId_;
}
void DeleteDiskReplicaPairRequest::setOwnerId(long ownerId)
{
ownerId_ = ownerId;
setParameter("OwnerId", std::to_string(ownerId));
}
std::string DeleteDiskReplicaPairRequest::getReplicaPairId()const
{
return replicaPairId_;
}
void DeleteDiskReplicaPairRequest::setReplicaPairId(const std::string& replicaPairId)
{
replicaPairId_ = replicaPairId;
setParameter("ReplicaPairId", replicaPairId);
}

44
ecs/src/model/DeleteDiskReplicaPairResult.cc Normal file
View File

@@ -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 <alibabacloud/ecs/model/DeleteDiskReplicaPairResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Ecs;
using namespace AlibabaCloud::Ecs::Model;
DeleteDiskReplicaPairResult::DeleteDiskReplicaPairResult() :
ServiceResult()
{}
DeleteDiskReplicaPairResult::DeleteDiskReplicaPairResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
DeleteDiskReplicaPairResult::~DeleteDiskReplicaPairResult()
{}
void DeleteDiskReplicaPairResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
}

2
ecs/src/model/DescribeCloudAssistantStatusResult.cc
View File

@@ -57,6 +57,8 @@ void DescribeCloudAssistantStatusResult::parse(const std::string &payload)
instanceCloudAssistantStatusSetObject.activeTaskCount = std::stol(valueInstanceCloudAssistantStatusSetInstanceCloudAssistantStatus["ActiveTaskCount"].asString());
if(!valueInstanceCloudAssistantStatusSetInstanceCloudAssistantStatus["LastInvokedTime"].isNull())
instanceCloudAssistantStatusSetObject.lastInvokedTime = valueInstanceCloudAssistantStatusSetInstanceCloudAssistantStatus["LastInvokedTime"].asString();
if(!valueInstanceCloudAssistantStatusSetInstanceCloudAssistantStatus["LastHeartbeatTime"].isNull())
instanceCloudAssistantStatusSetObject.lastHeartbeatTime = valueInstanceCloudAssistantStatusSetInstanceCloudAssistantStatus["LastHeartbeatTime"].asString();
instanceCloudAssistantStatusSet_.push_back(instanceCloudAssistantStatusSetObject);
}
if(!value["TotalCount"].isNull())

154
ecs/src/model/DescribeDedicatedBlockStorageClustersRequest.cc Normal file
View File

@@ -0,0 +1,154 @@
/*
* 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 <alibabacloud/ecs/model/DescribeDedicatedBlockStorageClustersRequest.h>
using AlibabaCloud::Ecs::Model::DescribeDedicatedBlockStorageClustersRequest;
DescribeDedicatedBlockStorageClustersRequest::DescribeDedicatedBlockStorageClustersRequest() :
RpcServiceRequest("ecs", "2014-05-26", "DescribeDedicatedBlockStorageClusters")
{
setMethod(HttpRequest::Method::Post);
}
DescribeDedicatedBlockStorageClustersRequest::~DescribeDedicatedBlockStorageClustersRequest()
{}
long DescribeDedicatedBlockStorageClustersRequest::getResourceOwnerId()const
{
return resourceOwnerId_;
}
void DescribeDedicatedBlockStorageClustersRequest::setResourceOwnerId(long resourceOwnerId)
{
resourceOwnerId_ = resourceOwnerId;
setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
}
std::string DescribeDedicatedBlockStorageClustersRequest::getRegionId()const
{
return regionId_;
}
void DescribeDedicatedBlockStorageClustersRequest::setRegionId(const std::string& regionId)
{
regionId_ = regionId;
setParameter("RegionId", regionId);
}
std::string DescribeDedicatedBlockStorageClustersRequest::getNextToken()const
{
return nextToken_;
}
void DescribeDedicatedBlockStorageClustersRequest::setNextToken(const std::string& nextToken)
{
nextToken_ = nextToken;
setParameter("NextToken", nextToken);
}
std::vector<std::string> DescribeDedicatedBlockStorageClustersRequest::getDedicatedBlockStorageClusterId()const
{
return dedicatedBlockStorageClusterId_;
}
void DescribeDedicatedBlockStorageClustersRequest::setDedicatedBlockStorageClusterId(const std::vector<std::string>& dedicatedBlockStorageClusterId)
{
dedicatedBlockStorageClusterId_ = dedicatedBlockStorageClusterId;
for(int dep1 = 0; dep1!= dedicatedBlockStorageClusterId.size(); dep1++) {
setParameter("DedicatedBlockStorageClusterId."+ std::to_string(dep1), dedicatedBlockStorageClusterId.at(dep1));
}
}
std::string DescribeDedicatedBlockStorageClustersRequest::getResourceOwnerAccount()const
{
return resourceOwnerAccount_;
}
void DescribeDedicatedBlockStorageClustersRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
{
resourceOwnerAccount_ = resourceOwnerAccount;
setParameter("ResourceOwnerAccount", resourceOwnerAccount);
}
std::string DescribeDedicatedBlockStorageClustersRequest::getOwnerAccount()const
{
return ownerAccount_;
}
void DescribeDedicatedBlockStorageClustersRequest::setOwnerAccount(const std::string& ownerAccount)
{
ownerAccount_ = ownerAccount;
setParameter("OwnerAccount", ownerAccount);
}
long DescribeDedicatedBlockStorageClustersRequest::getOwnerId()const
{
return ownerId_;
}
void DescribeDedicatedBlockStorageClustersRequest::setOwnerId(long ownerId)
{
ownerId_ = ownerId;
setParameter("OwnerId", std::to_string(ownerId));
}
std::string DescribeDedicatedBlockStorageClustersRequest::getZoneId()const
{
return zoneId_;
}
void DescribeDedicatedBlockStorageClustersRequest::setZoneId(const std::string& zoneId)
{
zoneId_ = zoneId;
setParameter("ZoneId", zoneId);
}
int DescribeDedicatedBlockStorageClustersRequest::getMaxResults()const
{
return maxResults_;
}
void DescribeDedicatedBlockStorageClustersRequest::setMaxResults(int maxResults)
{
maxResults_ = maxResults;
setParameter("MaxResults", std::to_string(maxResults));
}
std::string DescribeDedicatedBlockStorageClustersRequest::getCategory()const
{
return category_;
}
void DescribeDedicatedBlockStorageClustersRequest::setCategory(const std::string& category)
{
category_ = category;
setParameter("Category", category);
}
std::vector<std::string> DescribeDedicatedBlockStorageClustersRequest::getStatus()const
{
return status_;
}
void DescribeDedicatedBlockStorageClustersRequest::setStatus(const std::vector<std::string>& status)
{
status_ = status;
for(int dep1 = 0; dep1!= status.size(); dep1++) {
setParameter("Status."+ std::to_string(dep1), status.at(dep1));
}
}

85
ecs/src/model/DescribeDedicatedBlockStorageClustersResult.cc Normal file
View File

@@ -0,0 +1,85 @@
/*
* 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 <alibabacloud/ecs/model/DescribeDedicatedBlockStorageClustersResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Ecs;
using namespace AlibabaCloud::Ecs::Model;
DescribeDedicatedBlockStorageClustersResult::DescribeDedicatedBlockStorageClustersResult() :
ServiceResult()
{}
DescribeDedicatedBlockStorageClustersResult::DescribeDedicatedBlockStorageClustersResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
DescribeDedicatedBlockStorageClustersResult::~DescribeDedicatedBlockStorageClustersResult()
{}
void DescribeDedicatedBlockStorageClustersResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
auto allDedicatedBlockStorageClustersNode = value["DedicatedBlockStorageClusters"]["DedicatedBlockStorageCluster"];
for (auto valueDedicatedBlockStorageClustersDedicatedBlockStorageCluster : allDedicatedBlockStorageClustersNode)
{
DedicatedBlockStorageCluster dedicatedBlockStorageClustersObject;
if(!valueDedicatedBlockStorageClustersDedicatedBlockStorageCluster["DedicatedBlockStorageClusterId"].isNull())
dedicatedBlockStorageClustersObject.dedicatedBlockStorageClusterId = valueDedicatedBlockStorageClustersDedicatedBlockStorageCluster["DedicatedBlockStorageClusterId"].asString();
if(!valueDedicatedBlockStorageClustersDedicatedBlockStorageCluster["DedicatedBlockStorageClusterName"].isNull())
dedicatedBlockStorageClustersObject.dedicatedBlockStorageClusterName = valueDedicatedBlockStorageClustersDedicatedBlockStorageCluster["DedicatedBlockStorageClusterName"].asString();
if(!valueDedicatedBlockStorageClustersDedicatedBlockStorageCluster["Description"].isNull())
dedicatedBlockStorageClustersObject.description = valueDedicatedBlockStorageClustersDedicatedBlockStorageCluster["Description"].asString();
if(!valueDedicatedBlockStorageClustersDedicatedBlockStorageCluster["ZoneId"].isNull())
dedicatedBlockStorageClustersObject.zoneId = valueDedicatedBlockStorageClustersDedicatedBlockStorageCluster["ZoneId"].asString();
if(!valueDedicatedBlockStorageClustersDedicatedBlockStorageCluster["Status"].isNull())
dedicatedBlockStorageClustersObject.status = valueDedicatedBlockStorageClustersDedicatedBlockStorageCluster["Status"].asString();
if(!valueDedicatedBlockStorageClustersDedicatedBlockStorageCluster["Category"].isNull())
dedicatedBlockStorageClustersObject.category = valueDedicatedBlockStorageClustersDedicatedBlockStorageCluster["Category"].asString();
if(!valueDedicatedBlockStorageClustersDedicatedBlockStorageCluster["PerformanceLevel"].isNull())
dedicatedBlockStorageClustersObject.performanceLevel = valueDedicatedBlockStorageClustersDedicatedBlockStorageCluster["PerformanceLevel"].asString();
if(!valueDedicatedBlockStorageClustersDedicatedBlockStorageCluster["ExpiredTime"].isNull())
dedicatedBlockStorageClustersObject.expiredTime = valueDedicatedBlockStorageClustersDedicatedBlockStorageCluster["ExpiredTime"].asString();
if(!valueDedicatedBlockStorageClustersDedicatedBlockStorageCluster["CreateTime"].isNull())
dedicatedBlockStorageClustersObject.createTime = valueDedicatedBlockStorageClustersDedicatedBlockStorageCluster["CreateTime"].asString();
auto dedicatedBlockStorageClusterCapacityNode = value["DedicatedBlockStorageClusterCapacity"];
if(!dedicatedBlockStorageClusterCapacityNode["AvailableCapacity"].isNull())
dedicatedBlockStorageClustersObject.dedicatedBlockStorageClusterCapacity.availableCapacity = std::stol(dedicatedBlockStorageClusterCapacityNode["AvailableCapacity"].asString());
if(!dedicatedBlockStorageClusterCapacityNode["TotalCapacity"].isNull())
dedicatedBlockStorageClustersObject.dedicatedBlockStorageClusterCapacity.totalCapacity = std::stol(dedicatedBlockStorageClusterCapacityNode["TotalCapacity"].asString());
dedicatedBlockStorageClusters_.push_back(dedicatedBlockStorageClustersObject);
}
if(!value["NextToken"].isNull())
nextToken_ = value["NextToken"].asString();
}
std::vector<DescribeDedicatedBlockStorageClustersResult::DedicatedBlockStorageCluster> DescribeDedicatedBlockStorageClustersResult::getDedicatedBlockStorageClusters()const
{
return dedicatedBlockStorageClusters_;
}
std::string DescribeDedicatedBlockStorageClustersResult::getNextToken()const
{
return nextToken_;
}

106
ecs/src/model/DescribeDiskReplicaPairsRequest.cc Normal file
View File

@@ -0,0 +1,106 @@
/*
* 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 <alibabacloud/ecs/model/DescribeDiskReplicaPairsRequest.h>
using AlibabaCloud::Ecs::Model::DescribeDiskReplicaPairsRequest;
DescribeDiskReplicaPairsRequest::DescribeDiskReplicaPairsRequest() :
RpcServiceRequest("ecs", "2014-05-26", "DescribeDiskReplicaPairs")
{
setMethod(HttpRequest::Method::Post);
}
DescribeDiskReplicaPairsRequest::~DescribeDiskReplicaPairsRequest()
{}
long DescribeDiskReplicaPairsRequest::getResourceOwnerId()const
{
return resourceOwnerId_;
}
void DescribeDiskReplicaPairsRequest::setResourceOwnerId(long resourceOwnerId)
{
resourceOwnerId_ = resourceOwnerId;
setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
}
std::string DescribeDiskReplicaPairsRequest::getRegionId()const
{
return regionId_;
}
void DescribeDiskReplicaPairsRequest::setRegionId(const std::string& regionId)
{
regionId_ = regionId;
setParameter("RegionId", regionId);
}
std::string DescribeDiskReplicaPairsRequest::getNextToken()const
{
return nextToken_;
}
void DescribeDiskReplicaPairsRequest::setNextToken(const std::string& nextToken)
{
nextToken_ = nextToken;
setParameter("NextToken", nextToken);
}
std::string DescribeDiskReplicaPairsRequest::getResourceOwnerAccount()const
{
return resourceOwnerAccount_;
}
void DescribeDiskReplicaPairsRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
{
resourceOwnerAccount_ = resourceOwnerAccount;
setParameter("ResourceOwnerAccount", resourceOwnerAccount);
}
std::string DescribeDiskReplicaPairsRequest::getOwnerAccount()const
{
return ownerAccount_;
}
void DescribeDiskReplicaPairsRequest::setOwnerAccount(const std::string& ownerAccount)
{
ownerAccount_ = ownerAccount;
setParameter("OwnerAccount", ownerAccount);
}
long DescribeDiskReplicaPairsRequest::getOwnerId()const
{
return ownerId_;
}
void DescribeDiskReplicaPairsRequest::setOwnerId(long ownerId)
{
ownerId_ = ownerId;
setParameter("OwnerId", std::to_string(ownerId));
}
int DescribeDiskReplicaPairsRequest::getMaxResults()const
{
return maxResults_;
}
void DescribeDiskReplicaPairsRequest::setMaxResults(int maxResults)
{
maxResults_ = maxResults;
setParameter("MaxResults", std::to_string(maxResults));
}

78
ecs/src/model/DescribeDiskReplicaPairsResult.cc Normal file
View File

@@ -0,0 +1,78 @@
/*
* 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 <alibabacloud/ecs/model/DescribeDiskReplicaPairsResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Ecs;
using namespace AlibabaCloud::Ecs::Model;
DescribeDiskReplicaPairsResult::DescribeDiskReplicaPairsResult() :
ServiceResult()
{}
DescribeDiskReplicaPairsResult::DescribeDiskReplicaPairsResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
DescribeDiskReplicaPairsResult::~DescribeDiskReplicaPairsResult()
{}
void DescribeDiskReplicaPairsResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
auto allDiskReplicaPairsNode = value["DiskReplicaPairs"]["DiskReplicaPair"];
for (auto valueDiskReplicaPairsDiskReplicaPair : allDiskReplicaPairsNode)
{
DiskReplicaPair diskReplicaPairsObject;
if(!valueDiskReplicaPairsDiskReplicaPair["ReplicaPairId"].isNull())
diskReplicaPairsObject.replicaPairId = valueDiskReplicaPairsDiskReplicaPair["ReplicaPairId"].asString();
if(!valueDiskReplicaPairsDiskReplicaPair["SourceRegion"].isNull())
diskReplicaPairsObject.sourceRegion = valueDiskReplicaPairsDiskReplicaPair["SourceRegion"].asString();
if(!valueDiskReplicaPairsDiskReplicaPair["SourceDiskId"].isNull())
diskReplicaPairsObject.sourceDiskId = valueDiskReplicaPairsDiskReplicaPair["SourceDiskId"].asString();
if(!valueDiskReplicaPairsDiskReplicaPair["DestinationRegion"].isNull())
diskReplicaPairsObject.destinationRegion = valueDiskReplicaPairsDiskReplicaPair["DestinationRegion"].asString();
if(!valueDiskReplicaPairsDiskReplicaPair["DestinationDiskId"].isNull())
diskReplicaPairsObject.destinationDiskId = valueDiskReplicaPairsDiskReplicaPair["DestinationDiskId"].asString();
if(!valueDiskReplicaPairsDiskReplicaPair["PairName"].isNull())
diskReplicaPairsObject.pairName = valueDiskReplicaPairsDiskReplicaPair["PairName"].asString();
if(!valueDiskReplicaPairsDiskReplicaPair["Description"].isNull())
diskReplicaPairsObject.description = valueDiskReplicaPairsDiskReplicaPair["Description"].asString();
if(!valueDiskReplicaPairsDiskReplicaPair["Status"].isNull())
diskReplicaPairsObject.status = valueDiskReplicaPairsDiskReplicaPair["Status"].asString();
diskReplicaPairs_.push_back(diskReplicaPairsObject);
}
if(!value["NextToken"].isNull())
nextToken_ = value["NextToken"].asString();
}
std::string DescribeDiskReplicaPairsResult::getNextToken()const
{
return nextToken_;
}
std::vector<DescribeDiskReplicaPairsResult::DiskReplicaPair> DescribeDiskReplicaPairsResult::getDiskReplicaPairs()const
{
return diskReplicaPairs_;
}

2
ecs/src/model/DescribeDisksResult.cc
View File

@@ -117,6 +117,8 @@ void DescribeDisksResult::parse(const std::string &payload)
disksObject.bdfId = valueDisksDisk["BdfId"].asString();
if(!valueDisksDisk["SerialNumber"].isNull())
disksObject.serialNumber = valueDisksDisk["SerialNumber"].asString();
if(!valueDisksDisk["DedicatedBlockStorageClusterId"].isNull())
disksObject.dedicatedBlockStorageClusterId = valueDisksDisk["DedicatedBlockStorageClusterId"].asString();
auto allOperationLocksNode = valueDisksDisk["OperationLocks"]["OperationLock"];
for (auto valueDisksDiskOperationLocksOperationLock : allOperationLocksNode)
{

24
ecs/src/model/DescribeInstanceHistoryEventsRequest.cc
View File

@@ -130,6 +130,19 @@ void DescribeInstanceHistoryEventsRequest::setEventPublishTimeEnd(const std::str
setParameter("EventPublishTimeEnd", eventPublishTimeEnd);
}
std::vector<std::string> DescribeInstanceHistoryEventsRequest::getResourceId()const
{
return resourceId_;
}
void DescribeInstanceHistoryEventsRequest::setResourceId(const std::vector<std::string>& resourceId)
{
resourceId_ = resourceId;
for(int dep1 = 0; dep1!= resourceId.size(); dep1++) {
setParameter("ResourceId."+ std::to_string(dep1), resourceId.at(dep1));
}
}
std::vector<std::string> DescribeInstanceHistoryEventsRequest::getInstanceEventType()const
{
return instanceEventType_;
@@ -187,6 +200,17 @@ void DescribeInstanceHistoryEventsRequest::setOwnerId(long ownerId)
setParameter("OwnerId", std::to_string(ownerId));
}
std::string DescribeInstanceHistoryEventsRequest::getResourceType()const
{
return resourceType_;
}
void DescribeInstanceHistoryEventsRequest::setResourceType(const std::string& resourceType)
{
resourceType_ = resourceType;
setParameter("ResourceType", resourceType);
}
std::string DescribeInstanceHistoryEventsRequest::getEventPublishTimeStart()const
{
return eventPublishTimeStart_;

2
ecs/src/model/DescribeInstanceHistoryEventsResult.cc
View File

@@ -57,6 +57,8 @@ void DescribeInstanceHistoryEventsResult::parse(const std::string &payload)
instanceSystemEventSetObject.reason = valueInstanceSystemEventSetInstanceSystemEventType["Reason"].asString();
if(!valueInstanceSystemEventSetInstanceSystemEventType["ImpactLevel"].isNull())
instanceSystemEventSetObject.impactLevel = valueInstanceSystemEventSetInstanceSystemEventType["ImpactLevel"].asString();
if(!valueInstanceSystemEventSetInstanceSystemEventType["ResourceType"].isNull())
instanceSystemEventSetObject.resourceType = valueInstanceSystemEventSetInstanceSystemEventType["ResourceType"].asString();
auto eventTypeNode = value["EventType"];
if(!eventTypeNode["Code"].isNull())
instanceSystemEventSetObject.eventType.code = std::stoi(eventTypeNode["Code"].asString());

6
ecs/src/model/DescribeInstanceTypesResult.cc
View File

@@ -95,6 +95,12 @@ void DescribeInstanceTypesResult::parse(const std::string &payload)
instanceTypesObject.secondaryEniQueueNumber = std::stoi(valueInstanceTypesInstanceType["SecondaryEniQueueNumber"].asString());
if(!valueInstanceTypesInstanceType["DiskQuantity"].isNull())
instanceTypesObject.diskQuantity = std::stoi(valueInstanceTypesInstanceType["DiskQuantity"].asString());
if(!valueInstanceTypesInstanceType["EriQuantity"].isNull())
instanceTypesObject.eriQuantity = std::stoi(valueInstanceTypesInstanceType["EriQuantity"].asString());
if(!valueInstanceTypesInstanceType["QueuePairNumber"].isNull())
instanceTypesObject.queuePairNumber = std::stoi(valueInstanceTypesInstanceType["QueuePairNumber"].asString());
if(!valueInstanceTypesInstanceType["NvmeSupport"].isNull())
instanceTypesObject.nvmeSupport = valueInstanceTypesInstanceType["NvmeSupport"].asString();
instanceTypes_.push_back(instanceTypesObject);
}

4
ecs/src/model/DescribeInvocationsResult.cc
View File

@@ -59,6 +59,8 @@ void DescribeInvocationsResult::parse(const std::string &payload)
invocationsObject.frequency = valueInvocationsInvocation["Frequency"].asString();
if(!valueInvocationsInvocation["Timed"].isNull())
invocationsObject.timed = valueInvocationsInvocation["Timed"].asString() == "true";
if(!valueInvocationsInvocation["RepeatMode"].isNull())
invocationsObject.repeatMode = valueInvocationsInvocation["RepeatMode"].asString();
if(!valueInvocationsInvocation["InvokeStatus"].isNull())
invocationsObject.invokeStatus = valueInvocationsInvocation["InvokeStatus"].asString();
if(!valueInvocationsInvocation["InvocationStatus"].isNull())
@@ -75,6 +77,8 @@ void DescribeInvocationsResult::parse(const std::string &payload)
invokeInstancesObject.instanceId = valueInvocationsInvocationInvokeInstancesInvokeInstance["InstanceId"].asString();
if(!valueInvocationsInvocationInvokeInstancesInvokeInstance["Repeats"].isNull())
invokeInstancesObject.repeats = std::stoi(valueInvocationsInvocationInvokeInstancesInvokeInstance["Repeats"].asString());
if(!valueInvocationsInvocationInvokeInstancesInvokeInstance["Timed"].isNull())
invokeInstancesObject.timed = valueInvocationsInvocationInvokeInstancesInvokeInstance["Timed"].asString() == "true";
if(!valueInvocationsInvocationInvokeInstancesInvokeInstance["InstanceInvokeStatus"].isNull())
invokeInstancesObject.instanceInvokeStatus = valueInvocationsInvocationInvokeInstancesInvokeInstance["InstanceInvokeStatus"].asString();
if(!valueInvocationsInvocationInvokeInstancesInvokeInstance["InvocationStatus"].isNull())

94
ecs/src/model/DescribeNetworkInterfaceAttributeResult.cc
View File

@@ -124,14 +124,13 @@ void DescribeNetworkInterfaceAttributeResult::parse(const std::string &payload)
queueNumber_ = std::stoi(value["QueueNumber"].asString());
if(!value["OwnerId"].isNull())
ownerId_ = value["OwnerId"].asString();
if(!value["NetworkInterfaceTrafficMode"].isNull())
networkInterfaceTrafficMode_ = value["NetworkInterfaceTrafficMode"].asString();
if(!value["QueuePairNumber"].isNull())
queuePairNumber_ = std::stoi(value["QueuePairNumber"].asString());
}
std::string DescribeNetworkInterfaceAttributeResult::getStatus()const
{
return status_;
}
std::string DescribeNetworkInterfaceAttributeResult::getPrivateIpAddress()const
{
return privateIpAddress_;
@@ -142,11 +141,6 @@ std::string DescribeNetworkInterfaceAttributeResult::getDescription()const
return description_;
}
std::string DescribeNetworkInterfaceAttributeResult::getZoneId()const
{
return zoneId_;
}
std::string DescribeNetworkInterfaceAttributeResult::getResourceGroupId()const
{
return resourceGroupId_;
@@ -157,6 +151,51 @@ bool DescribeNetworkInterfaceAttributeResult::getServiceManaged()const
return serviceManaged_;
}
DescribeNetworkInterfaceAttributeResult::Attachment DescribeNetworkInterfaceAttributeResult::getAttachment()const
{
return attachment_;
}
std::string DescribeNetworkInterfaceAttributeResult::getNetworkInterfaceId()const
{
return networkInterfaceId_;
}
std::vector<DescribeNetworkInterfaceAttributeResult::Ipv6Set> DescribeNetworkInterfaceAttributeResult::getIpv6Sets()const
{
return ipv6Sets_;
}
std::string DescribeNetworkInterfaceAttributeResult::getOwnerId()const
{
return ownerId_;
}
DescribeNetworkInterfaceAttributeResult::AssociatedPublicIp DescribeNetworkInterfaceAttributeResult::getAssociatedPublicIp()const
{
return associatedPublicIp_;
}
std::vector<DescribeNetworkInterfaceAttributeResult::Tag> DescribeNetworkInterfaceAttributeResult::getTags()const
{
return tags_;
}
std::string DescribeNetworkInterfaceAttributeResult::getStatus()const
{
return status_;
}
std::string DescribeNetworkInterfaceAttributeResult::getNetworkInterfaceTrafficMode()const
{
return networkInterfaceTrafficMode_;
}
std::string DescribeNetworkInterfaceAttributeResult::getZoneId()const
{
return zoneId_;
}
std::string DescribeNetworkInterfaceAttributeResult::getInstanceId()const
{
return instanceId_;
@@ -172,16 +211,6 @@ std::string DescribeNetworkInterfaceAttributeResult::getNetworkInterfaceName()co
return networkInterfaceName_;
}
DescribeNetworkInterfaceAttributeResult::Attachment DescribeNetworkInterfaceAttributeResult::getAttachment()const
{
return attachment_;
}
std::string DescribeNetworkInterfaceAttributeResult::getNetworkInterfaceId()const
{
return networkInterfaceId_;
}
std::string DescribeNetworkInterfaceAttributeResult::getMacAddress()const
{
return macAddress_;
@@ -202,41 +231,26 @@ std::string DescribeNetworkInterfaceAttributeResult::getType()const
return type_;
}
std::vector<DescribeNetworkInterfaceAttributeResult::Ipv6Set> DescribeNetworkInterfaceAttributeResult::getIpv6Sets()const
{
return ipv6Sets_;
}
int DescribeNetworkInterfaceAttributeResult::getQueueNumber()const
{
return queueNumber_;
}
int DescribeNetworkInterfaceAttributeResult::getQueuePairNumber()const
{
return queuePairNumber_;
}
std::string DescribeNetworkInterfaceAttributeResult::getVpcId()const
{
return vpcId_;
}
std::string DescribeNetworkInterfaceAttributeResult::getOwnerId()const
{
return ownerId_;
}
DescribeNetworkInterfaceAttributeResult::AssociatedPublicIp DescribeNetworkInterfaceAttributeResult::getAssociatedPublicIp()const
{
return associatedPublicIp_;
}
std::string DescribeNetworkInterfaceAttributeResult::getCreationTime()const
{
return creationTime_;
}
std::vector<DescribeNetworkInterfaceAttributeResult::Tag> DescribeNetworkInterfaceAttributeResult::getTags()const
{
return tags_;
}
std::vector<DescribeNetworkInterfaceAttributeResult::PrivateIpSet> DescribeNetworkInterfaceAttributeResult::getPrivateIpSets()const
{
return privateIpSets_;

4
ecs/src/model/DescribeNetworkInterfacesResult.cc
View File

@@ -77,6 +77,10 @@ void DescribeNetworkInterfacesResult::parse(const std::string &payload)
networkInterfaceSetsObject.queueNumber = std::stoi(valueNetworkInterfaceSetsNetworkInterfaceSet["QueueNumber"].asString());
if(!valueNetworkInterfaceSetsNetworkInterfaceSet["OwnerId"].isNull())
networkInterfaceSetsObject.ownerId = valueNetworkInterfaceSetsNetworkInterfaceSet["OwnerId"].asString();
if(!valueNetworkInterfaceSetsNetworkInterfaceSet["NetworkInterfaceTrafficMode"].isNull())
networkInterfaceSetsObject.networkInterfaceTrafficMode = valueNetworkInterfaceSetsNetworkInterfaceSet["NetworkInterfaceTrafficMode"].asString();
if(!valueNetworkInterfaceSetsNetworkInterfaceSet["QueuePairNumber"].isNull())
networkInterfaceSetsObject.queuePairNumber = std::stoi(valueNetworkInterfaceSetsNetworkInterfaceSet["QueuePairNumber"].asString());
auto allPrivateIpSetsNode = valueNetworkInterfaceSetsNetworkInterfaceSet["PrivateIpSets"]["PrivateIpSet"];
for (auto valueNetworkInterfaceSetsNetworkInterfaceSetPrivateIpSetsPrivateIpSet : allPrivateIpSetsNode)
{

11
ecs/src/model/InvokeCommandRequest.cc
View File

@@ -71,6 +71,17 @@ void InvokeCommandRequest::setRegionId(const std::string& regionId)
setParameter("RegionId", regionId);
}
std::string InvokeCommandRequest::getRepeatMode()const
{
return repeatMode_;
}
void InvokeCommandRequest::setRepeatMode(const std::string& repeatMode)
{
repeatMode_ = repeatMode;
setParameter("RepeatMode", repeatMode);
}
std::string InvokeCommandRequest::getWindowsPasswordName()const
{
return windowsPasswordName_;

11
ecs/src/model/ModifyDiskAttributeRequest.cc
View File

@@ -71,6 +71,17 @@ void ModifyDiskAttributeRequest::setDeleteAutoSnapshot(bool deleteAutoSnapshot)
setParameter("DeleteAutoSnapshot", deleteAutoSnapshot ? "true" : "false");
}
std::string ModifyDiskAttributeRequest::getRegionId()const
{
return regionId_;
}
void ModifyDiskAttributeRequest::setRegionId(const std::string& regionId)
{
regionId_ = regionId;
setParameter("RegionId", regionId);
}
std::vector<std::string> ModifyDiskAttributeRequest::getDiskIds()const
{
return diskIds_;

11
ecs/src/model/RunCommandRequest.cc
View File

@@ -126,6 +126,17 @@ void RunCommandRequest::setContentEncoding(const std::string& contentEncoding)
setParameter("ContentEncoding", contentEncoding);
}
std::string RunCommandRequest::getRepeatMode()const
{
return repeatMode_;
}
void RunCommandRequest::setRepeatMode(const std::string& repeatMode)
{
repeatMode_ = repeatMode;
setParameter("RepeatMode", repeatMode);
}
std::string RunCommandRequest::getWindowsPasswordName()const
{
return windowsPasswordName_;

95
ecs/src/model/StartDiskReplicaPairRequest.cc Normal file
View File

@@ -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 <alibabacloud/ecs/model/StartDiskReplicaPairRequest.h>
using AlibabaCloud::Ecs::Model::StartDiskReplicaPairRequest;
StartDiskReplicaPairRequest::StartDiskReplicaPairRequest() :
RpcServiceRequest("ecs", "2014-05-26", "StartDiskReplicaPair")
{
setMethod(HttpRequest::Method::Post);
}
StartDiskReplicaPairRequest::~StartDiskReplicaPairRequest()
{}
long StartDiskReplicaPairRequest::getResourceOwnerId()const
{
return resourceOwnerId_;
}
void StartDiskReplicaPairRequest::setResourceOwnerId(long resourceOwnerId)
{
resourceOwnerId_ = resourceOwnerId;
setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
}
std::string StartDiskReplicaPairRequest::getRegionId()const
{
return regionId_;
}
void StartDiskReplicaPairRequest::setRegionId(const std::string& regionId)
{
regionId_ = regionId;
setParameter("RegionId", regionId);
}
std::string StartDiskReplicaPairRequest::getResourceOwnerAccount()const
{
return resourceOwnerAccount_;
}
void StartDiskReplicaPairRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
{
resourceOwnerAccount_ = resourceOwnerAccount;
setParameter("ResourceOwnerAccount", resourceOwnerAccount);
}
std::string StartDiskReplicaPairRequest::getOwnerAccount()const
{
return ownerAccount_;
}
void StartDiskReplicaPairRequest::setOwnerAccount(const std::string& ownerAccount)
{
ownerAccount_ = ownerAccount;
setParameter("OwnerAccount", ownerAccount);
}
long StartDiskReplicaPairRequest::getOwnerId()const
{
return ownerId_;
}
void StartDiskReplicaPairRequest::setOwnerId(long ownerId)
{
ownerId_ = ownerId;
setParameter("OwnerId", std::to_string(ownerId));
}
std::string StartDiskReplicaPairRequest::getReplicaPairId()const
{
return replicaPairId_;
}
void StartDiskReplicaPairRequest::setReplicaPairId(const std::string& replicaPairId)
{
replicaPairId_ = replicaPairId;
setParameter("ReplicaPairId", replicaPairId);
}

44
ecs/src/model/StartDiskReplicaPairResult.cc Normal file
View File

@@ -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 <alibabacloud/ecs/model/StartDiskReplicaPairResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Ecs;
using namespace AlibabaCloud::Ecs::Model;
StartDiskReplicaPairResult::StartDiskReplicaPairResult() :
ServiceResult()
{}
StartDiskReplicaPairResult::StartDiskReplicaPairResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
StartDiskReplicaPairResult::~StartDiskReplicaPairResult()
{}
void StartDiskReplicaPairResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
}

95
ecs/src/model/StopDiskReplicaPairRequest.cc Normal file
View File

@@ -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 <alibabacloud/ecs/model/StopDiskReplicaPairRequest.h>
using AlibabaCloud::Ecs::Model::StopDiskReplicaPairRequest;
StopDiskReplicaPairRequest::StopDiskReplicaPairRequest() :
RpcServiceRequest("ecs", "2014-05-26", "StopDiskReplicaPair")
{
setMethod(HttpRequest::Method::Post);
}
StopDiskReplicaPairRequest::~StopDiskReplicaPairRequest()
{}
long StopDiskReplicaPairRequest::getResourceOwnerId()const
{
return resourceOwnerId_;
}
void StopDiskReplicaPairRequest::setResourceOwnerId(long resourceOwnerId)
{
resourceOwnerId_ = resourceOwnerId;
setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
}
std::string StopDiskReplicaPairRequest::getRegionId()const
{
return regionId_;
}
void StopDiskReplicaPairRequest::setRegionId(const std::string& regionId)
{
regionId_ = regionId;
setParameter("RegionId", regionId);
}
std::string StopDiskReplicaPairRequest::getResourceOwnerAccount()const
{
return resourceOwnerAccount_;
}
void StopDiskReplicaPairRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
{
resourceOwnerAccount_ = resourceOwnerAccount;
setParameter("ResourceOwnerAccount", resourceOwnerAccount);
}
std::string StopDiskReplicaPairRequest::getOwnerAccount()const
{
return ownerAccount_;
}
void StopDiskReplicaPairRequest::setOwnerAccount(const std::string& ownerAccount)
{
ownerAccount_ = ownerAccount;
setParameter("OwnerAccount", ownerAccount);
}
long StopDiskReplicaPairRequest::getOwnerId()const
{
return ownerId_;
}
void StopDiskReplicaPairRequest::setOwnerId(long ownerId)
{
ownerId_ = ownerId;
setParameter("OwnerId", std::to_string(ownerId));
}
std::string StopDiskReplicaPairRequest::getReplicaPairId()const
{
return replicaPairId_;
}
void StopDiskReplicaPairRequest::setReplicaPairId(const std::string& replicaPairId)
{
replicaPairId_ = replicaPairId;
setParameter("ReplicaPairId", replicaPairId);
}

44
ecs/src/model/StopDiskReplicaPairResult.cc Normal file
View File

@@ -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 <alibabacloud/ecs/model/StopDiskReplicaPairResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Ecs;
using namespace AlibabaCloud::Ecs::Model;
StopDiskReplicaPairResult::StopDiskReplicaPairResult() :
ServiceResult()
{}
StopDiskReplicaPairResult::StopDiskReplicaPairResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
StopDiskReplicaPairResult::~StopDiskReplicaPairResult()
{}
void StopDiskReplicaPairResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
}