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

Generate SDK by new Generator

Browse Source
This commit is contained in:
wb-hx510875
2019-09-18 11:18:56 +08:00
parent be86048a76
commit f3eaf1d292
9054 changed files with 325898 additions and 381375 deletions
Download Patch File Download Diff File Expand all files Collapse all files

108
dbs/CMakeLists.txt
View File

@@ -21,65 +21,85 @@ set(dbs_public_header
include/alibabacloud/dbs/DbsExport.h )
set(dbs_public_header_model
include/alibabacloud/dbs/model/DescribeBackupPlanListRequest.h
include/alibabacloud/dbs/model/DescribeBackupPlanListResult.h
include/alibabacloud/dbs/model/RenewBackupPlanRequest.h
include/alibabacloud/dbs/model/RenewBackupPlanResult.h
include/alibabacloud/dbs/model/DescribeFullBackupListRequest.h
include/alibabacloud/dbs/model/DescribeFullBackupListResult.h
include/alibabacloud/dbs/model/UpgradeBackupPlanRequest.h
include/alibabacloud/dbs/model/UpgradeBackupPlanResult.h
include/alibabacloud/dbs/model/DescribeRestoreTaskListRequest.h
include/alibabacloud/dbs/model/DescribeRestoreTaskListResult.h
include/alibabacloud/dbs/model/ModifyBackupPlanNameRequest.h
include/alibabacloud/dbs/model/ModifyBackupPlanNameResult.h
include/alibabacloud/dbs/model/StopBackupPlanRequest.h
include/alibabacloud/dbs/model/StopBackupPlanResult.h
include/alibabacloud/dbs/model/ModifyBackupSourceEndpointRequest.h
include/alibabacloud/dbs/model/ModifyBackupSourceEndpointResult.h
include/alibabacloud/dbs/model/DescribePreCheckProgressListRequest.h
include/alibabacloud/dbs/model/DescribePreCheckProgressListResult.h
include/alibabacloud/dbs/model/ModifyBackupObjectsRequest.h
include/alibabacloud/dbs/model/ModifyBackupObjectsResult.h
include/alibabacloud/dbs/model/ConfigureBackupPlanRequest.h
include/alibabacloud/dbs/model/ConfigureBackupPlanResult.h
include/alibabacloud/dbs/model/CreateBackupPlanRequest.h
include/alibabacloud/dbs/model/CreateBackupPlanResult.h
include/alibabacloud/dbs/model/CreateRestoreTaskRequest.h
include/alibabacloud/dbs/model/CreateRestoreTaskResult.h
include/alibabacloud/dbs/model/DescribeBackupGatewayListRequest.h
include/alibabacloud/dbs/model/DescribeBackupGatewayListResult.h
include/alibabacloud/dbs/model/DescribeBackupPlanListRequest.h
include/alibabacloud/dbs/model/DescribeBackupPlanListResult.h
include/alibabacloud/dbs/model/DescribeFullBackupListRequest.h
include/alibabacloud/dbs/model/DescribeFullBackupListResult.h
include/alibabacloud/dbs/model/DescribeIncrementBackupListRequest.h
include/alibabacloud/dbs/model/DescribeIncrementBackupListResult.h
include/alibabacloud/dbs/model/DescribeNodeCidrListRequest.h
include/alibabacloud/dbs/model/DescribeNodeCidrListResult.h
include/alibabacloud/dbs/model/DescribePreCheckProgressListRequest.h
include/alibabacloud/dbs/model/DescribePreCheckProgressListResult.h
include/alibabacloud/dbs/model/DescribeRestoreTaskListRequest.h
include/alibabacloud/dbs/model/DescribeRestoreTaskListResult.h
include/alibabacloud/dbs/model/ModifyBackupObjectsRequest.h
include/alibabacloud/dbs/model/ModifyBackupObjectsResult.h
include/alibabacloud/dbs/model/ModifyBackupPlanNameRequest.h
include/alibabacloud/dbs/model/ModifyBackupPlanNameResult.h
include/alibabacloud/dbs/model/ModifyBackupSourceEndpointRequest.h
include/alibabacloud/dbs/model/ModifyBackupSourceEndpointResult.h
include/alibabacloud/dbs/model/ModifyBackupStrategyRequest.h
include/alibabacloud/dbs/model/ModifyBackupStrategyResult.h
include/alibabacloud/dbs/model/RenewBackupPlanRequest.h
include/alibabacloud/dbs/model/RenewBackupPlanResult.h
include/alibabacloud/dbs/model/StartBackupPlanRequest.h
include/alibabacloud/dbs/model/StartBackupPlanResult.h
include/alibabacloud/dbs/model/StartRestoreTaskRequest.h
include/alibabacloud/dbs/model/StartRestoreTaskResult.h
include/alibabacloud/dbs/model/DescribeNodeCidrListRequest.h
include/alibabacloud/dbs/model/DescribeNodeCidrListResult.h )
include/alibabacloud/dbs/model/StopBackupPlanRequest.h
include/alibabacloud/dbs/model/StopBackupPlanResult.h
include/alibabacloud/dbs/model/UpgradeBackupPlanRequest.h
include/alibabacloud/dbs/model/UpgradeBackupPlanResult.h )
set(dbs_src
src/DbsClient.cc
src/model/DescribeBackupPlanListRequest.cc
src/model/DescribeBackupPlanListResult.cc
src/model/RenewBackupPlanRequest.cc
src/model/RenewBackupPlanResult.cc
src/model/DescribeFullBackupListRequest.cc
src/model/DescribeFullBackupListResult.cc
src/model/UpgradeBackupPlanRequest.cc
src/model/UpgradeBackupPlanResult.cc
src/model/DescribeRestoreTaskListRequest.cc
src/model/DescribeRestoreTaskListResult.cc
src/model/ModifyBackupPlanNameRequest.cc
src/model/ModifyBackupPlanNameResult.cc
src/model/StopBackupPlanRequest.cc
src/model/StopBackupPlanResult.cc
src/model/ModifyBackupSourceEndpointRequest.cc
src/model/ModifyBackupSourceEndpointResult.cc
src/model/DescribePreCheckProgressListRequest.cc
src/model/DescribePreCheckProgressListResult.cc
src/model/ModifyBackupObjectsRequest.cc
src/model/ModifyBackupObjectsResult.cc
src/model/ConfigureBackupPlanRequest.cc
src/model/ConfigureBackupPlanResult.cc
src/model/CreateBackupPlanRequest.cc
src/model/CreateBackupPlanResult.cc
src/model/CreateRestoreTaskRequest.cc
src/model/CreateRestoreTaskResult.cc
src/model/DescribeBackupGatewayListRequest.cc
src/model/DescribeBackupGatewayListResult.cc
src/model/DescribeBackupPlanListRequest.cc
src/model/DescribeBackupPlanListResult.cc
src/model/DescribeFullBackupListRequest.cc
src/model/DescribeFullBackupListResult.cc
src/model/DescribeIncrementBackupListRequest.cc
src/model/DescribeIncrementBackupListResult.cc
src/model/DescribeNodeCidrListRequest.cc
src/model/DescribeNodeCidrListResult.cc
src/model/DescribePreCheckProgressListRequest.cc
src/model/DescribePreCheckProgressListResult.cc
src/model/DescribeRestoreTaskListRequest.cc
src/model/DescribeRestoreTaskListResult.cc
src/model/ModifyBackupObjectsRequest.cc
src/model/ModifyBackupObjectsResult.cc
src/model/ModifyBackupPlanNameRequest.cc
src/model/ModifyBackupPlanNameResult.cc
src/model/ModifyBackupSourceEndpointRequest.cc
src/model/ModifyBackupSourceEndpointResult.cc
src/model/ModifyBackupStrategyRequest.cc
src/model/ModifyBackupStrategyResult.cc
src/model/RenewBackupPlanRequest.cc
src/model/RenewBackupPlanResult.cc
src/model/StartBackupPlanRequest.cc
src/model/StartBackupPlanResult.cc
src/model/StartRestoreTaskRequest.cc
src/model/StartRestoreTaskResult.cc
src/model/DescribeNodeCidrListRequest.cc
src/model/DescribeNodeCidrListResult.cc )
src/model/StopBackupPlanRequest.cc
src/model/StopBackupPlanResult.cc
src/model/UpgradeBackupPlanRequest.cc
src/model/UpgradeBackupPlanResult.cc )
add_library(dbs ${LIB_TYPE}
${dbs_public_header}

272
dbs/include/alibabacloud/dbs/DbsClient.h
View File

@@ -22,44 +22,44 @@
#include <alibabacloud/core/EndpointProvider.h>
#include <alibabacloud/core/RpcServiceClient.h>
#include "DbsExport.h"
#include "model/DescribeBackupPlanListRequest.h"
#include "model/DescribeBackupPlanListResult.h"
#include "model/CreateBackupPlanRequest.h"
#include "model/CreateBackupPlanResult.h"
#include "model/StartBackupPlanRequest.h"
#include "model/StartBackupPlanResult.h"
#include "model/RenewBackupPlanRequest.h"
#include "model/RenewBackupPlanResult.h"
#include "model/DescribeFullBackupListRequest.h"
#include "model/DescribeFullBackupListResult.h"
#include "model/UpgradeBackupPlanRequest.h"
#include "model/UpgradeBackupPlanResult.h"
#include "model/DescribeRestoreTaskListRequest.h"
#include "model/DescribeRestoreTaskListResult.h"
#include "model/ModifyBackupPlanNameRequest.h"
#include "model/ModifyBackupPlanNameResult.h"
#include "model/StopBackupPlanRequest.h"
#include "model/StopBackupPlanResult.h"
#include "model/DescribeBackupGatewayListRequest.h"
#include "model/DescribeBackupGatewayListResult.h"
#include "model/ModifyBackupSourceEndpointRequest.h"
#include "model/ModifyBackupSourceEndpointResult.h"
#include "model/DescribePreCheckProgressListRequest.h"
#include "model/DescribePreCheckProgressListResult.h"
#include "model/ModifyBackupObjectsRequest.h"
#include "model/ModifyBackupObjectsResult.h"
#include "model/DescribeIncrementBackupListRequest.h"
#include "model/DescribeIncrementBackupListResult.h"
#include "model/CreateRestoreTaskRequest.h"
#include "model/CreateRestoreTaskResult.h"
#include "model/ConfigureBackupPlanRequest.h"
#include "model/ConfigureBackupPlanResult.h"
#include "model/ModifyBackupStrategyRequest.h"
#include "model/ModifyBackupStrategyResult.h"
#include "model/StartRestoreTaskRequest.h"
#include "model/StartRestoreTaskResult.h"
#include "model/CreateBackupPlanRequest.h"
#include "model/CreateBackupPlanResult.h"
#include "model/CreateRestoreTaskRequest.h"
#include "model/CreateRestoreTaskResult.h"
#include "model/DescribeBackupGatewayListRequest.h"
#include "model/DescribeBackupGatewayListResult.h"
#include "model/DescribeBackupPlanListRequest.h"
#include "model/DescribeBackupPlanListResult.h"
#include "model/DescribeFullBackupListRequest.h"
#include "model/DescribeFullBackupListResult.h"
#include "model/DescribeIncrementBackupListRequest.h"
#include "model/DescribeIncrementBackupListResult.h"
#include "model/DescribeNodeCidrListRequest.h"
#include "model/DescribeNodeCidrListResult.h"
#include "model/DescribePreCheckProgressListRequest.h"
#include "model/DescribePreCheckProgressListResult.h"
#include "model/DescribeRestoreTaskListRequest.h"
#include "model/DescribeRestoreTaskListResult.h"
#include "model/ModifyBackupObjectsRequest.h"
#include "model/ModifyBackupObjectsResult.h"
#include "model/ModifyBackupPlanNameRequest.h"
#include "model/ModifyBackupPlanNameResult.h"
#include "model/ModifyBackupSourceEndpointRequest.h"
#include "model/ModifyBackupSourceEndpointResult.h"
#include "model/ModifyBackupStrategyRequest.h"
#include "model/ModifyBackupStrategyResult.h"
#include "model/RenewBackupPlanRequest.h"
#include "model/RenewBackupPlanResult.h"
#include "model/StartBackupPlanRequest.h"
#include "model/StartBackupPlanResult.h"
#include "model/StartRestoreTaskRequest.h"
#include "model/StartRestoreTaskResult.h"
#include "model/StopBackupPlanRequest.h"
#include "model/StopBackupPlanResult.h"
#include "model/UpgradeBackupPlanRequest.h"
#include "model/UpgradeBackupPlanResult.h"
namespace AlibabaCloud
@@ -69,125 +69,125 @@ namespace AlibabaCloud
class ALIBABACLOUD_DBS_EXPORT DbsClient : public RpcServiceClient
{
public:
typedef Outcome<Error, Model::DescribeBackupPlanListResult> DescribeBackupPlanListOutcome;
typedef std::future<DescribeBackupPlanListOutcome> DescribeBackupPlanListOutcomeCallable;
typedef std::function<void(const DbsClient*, const Model::DescribeBackupPlanListRequest&, const DescribeBackupPlanListOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeBackupPlanListAsyncHandler;
typedef Outcome<Error, Model::CreateBackupPlanResult> CreateBackupPlanOutcome;
typedef std::future<CreateBackupPlanOutcome> CreateBackupPlanOutcomeCallable;
typedef std::function<void(const DbsClient*, const Model::CreateBackupPlanRequest&, const CreateBackupPlanOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateBackupPlanAsyncHandler;
typedef Outcome<Error, Model::StartBackupPlanResult> StartBackupPlanOutcome;
typedef std::future<StartBackupPlanOutcome> StartBackupPlanOutcomeCallable;
typedef std::function<void(const DbsClient*, const Model::StartBackupPlanRequest&, const StartBackupPlanOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> StartBackupPlanAsyncHandler;
typedef Outcome<Error, Model::RenewBackupPlanResult> RenewBackupPlanOutcome;
typedef std::future<RenewBackupPlanOutcome> RenewBackupPlanOutcomeCallable;
typedef std::function<void(const DbsClient*, const Model::RenewBackupPlanRequest&, const RenewBackupPlanOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> RenewBackupPlanAsyncHandler;
typedef Outcome<Error, Model::DescribeFullBackupListResult> DescribeFullBackupListOutcome;
typedef std::future<DescribeFullBackupListOutcome> DescribeFullBackupListOutcomeCallable;
typedef std::function<void(const DbsClient*, const Model::DescribeFullBackupListRequest&, const DescribeFullBackupListOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeFullBackupListAsyncHandler;
typedef Outcome<Error, Model::UpgradeBackupPlanResult> UpgradeBackupPlanOutcome;
typedef std::future<UpgradeBackupPlanOutcome> UpgradeBackupPlanOutcomeCallable;
typedef std::function<void(const DbsClient*, const Model::UpgradeBackupPlanRequest&, const UpgradeBackupPlanOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> UpgradeBackupPlanAsyncHandler;
typedef Outcome<Error, Model::DescribeRestoreTaskListResult> DescribeRestoreTaskListOutcome;
typedef std::future<DescribeRestoreTaskListOutcome> DescribeRestoreTaskListOutcomeCallable;
typedef std::function<void(const DbsClient*, const Model::DescribeRestoreTaskListRequest&, const DescribeRestoreTaskListOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeRestoreTaskListAsyncHandler;
typedef Outcome<Error, Model::ModifyBackupPlanNameResult> ModifyBackupPlanNameOutcome;
typedef std::future<ModifyBackupPlanNameOutcome> ModifyBackupPlanNameOutcomeCallable;
typedef std::function<void(const DbsClient*, const Model::ModifyBackupPlanNameRequest&, const ModifyBackupPlanNameOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ModifyBackupPlanNameAsyncHandler;
typedef Outcome<Error, Model::StopBackupPlanResult> StopBackupPlanOutcome;
typedef std::future<StopBackupPlanOutcome> StopBackupPlanOutcomeCallable;
typedef std::function<void(const DbsClient*, const Model::StopBackupPlanRequest&, const StopBackupPlanOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> StopBackupPlanAsyncHandler;
typedef Outcome<Error, Model::DescribeBackupGatewayListResult> DescribeBackupGatewayListOutcome;
typedef std::future<DescribeBackupGatewayListOutcome> DescribeBackupGatewayListOutcomeCallable;
typedef std::function<void(const DbsClient*, const Model::DescribeBackupGatewayListRequest&, const DescribeBackupGatewayListOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeBackupGatewayListAsyncHandler;
typedef Outcome<Error, Model::ModifyBackupSourceEndpointResult> ModifyBackupSourceEndpointOutcome;
typedef std::future<ModifyBackupSourceEndpointOutcome> ModifyBackupSourceEndpointOutcomeCallable;
typedef std::function<void(const DbsClient*, const Model::ModifyBackupSourceEndpointRequest&, const ModifyBackupSourceEndpointOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ModifyBackupSourceEndpointAsyncHandler;
typedef Outcome<Error, Model::DescribePreCheckProgressListResult> DescribePreCheckProgressListOutcome;
typedef std::future<DescribePreCheckProgressListOutcome> DescribePreCheckProgressListOutcomeCallable;
typedef std::function<void(const DbsClient*, const Model::DescribePreCheckProgressListRequest&, const DescribePreCheckProgressListOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribePreCheckProgressListAsyncHandler;
typedef Outcome<Error, Model::ModifyBackupObjectsResult> ModifyBackupObjectsOutcome;
typedef std::future<ModifyBackupObjectsOutcome> ModifyBackupObjectsOutcomeCallable;
typedef std::function<void(const DbsClient*, const Model::ModifyBackupObjectsRequest&, const ModifyBackupObjectsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ModifyBackupObjectsAsyncHandler;
typedef Outcome<Error, Model::DescribeIncrementBackupListResult> DescribeIncrementBackupListOutcome;
typedef std::future<DescribeIncrementBackupListOutcome> DescribeIncrementBackupListOutcomeCallable;
typedef std::function<void(const DbsClient*, const Model::DescribeIncrementBackupListRequest&, const DescribeIncrementBackupListOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeIncrementBackupListAsyncHandler;
typedef Outcome<Error, Model::CreateRestoreTaskResult> CreateRestoreTaskOutcome;
typedef std::future<CreateRestoreTaskOutcome> CreateRestoreTaskOutcomeCallable;
typedef std::function<void(const DbsClient*, const Model::CreateRestoreTaskRequest&, const CreateRestoreTaskOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateRestoreTaskAsyncHandler;
typedef Outcome<Error, Model::ConfigureBackupPlanResult> ConfigureBackupPlanOutcome;
typedef std::future<ConfigureBackupPlanOutcome> ConfigureBackupPlanOutcomeCallable;
typedef std::function<void(const DbsClient*, const Model::ConfigureBackupPlanRequest&, const ConfigureBackupPlanOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ConfigureBackupPlanAsyncHandler;
typedef Outcome<Error, Model::ModifyBackupStrategyResult> ModifyBackupStrategyOutcome;
typedef std::future<ModifyBackupStrategyOutcome> ModifyBackupStrategyOutcomeCallable;
typedef std::function<void(const DbsClient*, const Model::ModifyBackupStrategyRequest&, const ModifyBackupStrategyOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ModifyBackupStrategyAsyncHandler;
typedef Outcome<Error, Model::StartRestoreTaskResult> StartRestoreTaskOutcome;
typedef std::future<StartRestoreTaskOutcome> StartRestoreTaskOutcomeCallable;
typedef std::function<void(const DbsClient*, const Model::StartRestoreTaskRequest&, const StartRestoreTaskOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> StartRestoreTaskAsyncHandler;
typedef Outcome<Error, Model::CreateBackupPlanResult> CreateBackupPlanOutcome;
typedef std::future<CreateBackupPlanOutcome> CreateBackupPlanOutcomeCallable;
typedef std::function<void(const DbsClient*, const Model::CreateBackupPlanRequest&, const CreateBackupPlanOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateBackupPlanAsyncHandler;
typedef Outcome<Error, Model::CreateRestoreTaskResult> CreateRestoreTaskOutcome;
typedef std::future<CreateRestoreTaskOutcome> CreateRestoreTaskOutcomeCallable;
typedef std::function<void(const DbsClient*, const Model::CreateRestoreTaskRequest&, const CreateRestoreTaskOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateRestoreTaskAsyncHandler;
typedef Outcome<Error, Model::DescribeBackupGatewayListResult> DescribeBackupGatewayListOutcome;
typedef std::future<DescribeBackupGatewayListOutcome> DescribeBackupGatewayListOutcomeCallable;
typedef std::function<void(const DbsClient*, const Model::DescribeBackupGatewayListRequest&, const DescribeBackupGatewayListOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeBackupGatewayListAsyncHandler;
typedef Outcome<Error, Model::DescribeBackupPlanListResult> DescribeBackupPlanListOutcome;
typedef std::future<DescribeBackupPlanListOutcome> DescribeBackupPlanListOutcomeCallable;
typedef std::function<void(const DbsClient*, const Model::DescribeBackupPlanListRequest&, const DescribeBackupPlanListOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeBackupPlanListAsyncHandler;
typedef Outcome<Error, Model::DescribeFullBackupListResult> DescribeFullBackupListOutcome;
typedef std::future<DescribeFullBackupListOutcome> DescribeFullBackupListOutcomeCallable;
typedef std::function<void(const DbsClient*, const Model::DescribeFullBackupListRequest&, const DescribeFullBackupListOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeFullBackupListAsyncHandler;
typedef Outcome<Error, Model::DescribeIncrementBackupListResult> DescribeIncrementBackupListOutcome;
typedef std::future<DescribeIncrementBackupListOutcome> DescribeIncrementBackupListOutcomeCallable;
typedef std::function<void(const DbsClient*, const Model::DescribeIncrementBackupListRequest&, const DescribeIncrementBackupListOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeIncrementBackupListAsyncHandler;
typedef Outcome<Error, Model::DescribeNodeCidrListResult> DescribeNodeCidrListOutcome;
typedef std::future<DescribeNodeCidrListOutcome> DescribeNodeCidrListOutcomeCallable;
typedef std::function<void(const DbsClient*, const Model::DescribeNodeCidrListRequest&, const DescribeNodeCidrListOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeNodeCidrListAsyncHandler;
typedef Outcome<Error, Model::DescribePreCheckProgressListResult> DescribePreCheckProgressListOutcome;
typedef std::future<DescribePreCheckProgressListOutcome> DescribePreCheckProgressListOutcomeCallable;
typedef std::function<void(const DbsClient*, const Model::DescribePreCheckProgressListRequest&, const DescribePreCheckProgressListOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribePreCheckProgressListAsyncHandler;
typedef Outcome<Error, Model::DescribeRestoreTaskListResult> DescribeRestoreTaskListOutcome;
typedef std::future<DescribeRestoreTaskListOutcome> DescribeRestoreTaskListOutcomeCallable;
typedef std::function<void(const DbsClient*, const Model::DescribeRestoreTaskListRequest&, const DescribeRestoreTaskListOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeRestoreTaskListAsyncHandler;
typedef Outcome<Error, Model::ModifyBackupObjectsResult> ModifyBackupObjectsOutcome;
typedef std::future<ModifyBackupObjectsOutcome> ModifyBackupObjectsOutcomeCallable;
typedef std::function<void(const DbsClient*, const Model::ModifyBackupObjectsRequest&, const ModifyBackupObjectsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ModifyBackupObjectsAsyncHandler;
typedef Outcome<Error, Model::ModifyBackupPlanNameResult> ModifyBackupPlanNameOutcome;
typedef std::future<ModifyBackupPlanNameOutcome> ModifyBackupPlanNameOutcomeCallable;
typedef std::function<void(const DbsClient*, const Model::ModifyBackupPlanNameRequest&, const ModifyBackupPlanNameOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ModifyBackupPlanNameAsyncHandler;
typedef Outcome<Error, Model::ModifyBackupSourceEndpointResult> ModifyBackupSourceEndpointOutcome;
typedef std::future<ModifyBackupSourceEndpointOutcome> ModifyBackupSourceEndpointOutcomeCallable;
typedef std::function<void(const DbsClient*, const Model::ModifyBackupSourceEndpointRequest&, const ModifyBackupSourceEndpointOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ModifyBackupSourceEndpointAsyncHandler;
typedef Outcome<Error, Model::ModifyBackupStrategyResult> ModifyBackupStrategyOutcome;
typedef std::future<ModifyBackupStrategyOutcome> ModifyBackupStrategyOutcomeCallable;
typedef std::function<void(const DbsClient*, const Model::ModifyBackupStrategyRequest&, const ModifyBackupStrategyOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ModifyBackupStrategyAsyncHandler;
typedef Outcome<Error, Model::RenewBackupPlanResult> RenewBackupPlanOutcome;
typedef std::future<RenewBackupPlanOutcome> RenewBackupPlanOutcomeCallable;
typedef std::function<void(const DbsClient*, const Model::RenewBackupPlanRequest&, const RenewBackupPlanOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> RenewBackupPlanAsyncHandler;
typedef Outcome<Error, Model::StartBackupPlanResult> StartBackupPlanOutcome;
typedef std::future<StartBackupPlanOutcome> StartBackupPlanOutcomeCallable;
typedef std::function<void(const DbsClient*, const Model::StartBackupPlanRequest&, const StartBackupPlanOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> StartBackupPlanAsyncHandler;
typedef Outcome<Error, Model::StartRestoreTaskResult> StartRestoreTaskOutcome;
typedef std::future<StartRestoreTaskOutcome> StartRestoreTaskOutcomeCallable;
typedef std::function<void(const DbsClient*, const Model::StartRestoreTaskRequest&, const StartRestoreTaskOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> StartRestoreTaskAsyncHandler;
typedef Outcome<Error, Model::StopBackupPlanResult> StopBackupPlanOutcome;
typedef std::future<StopBackupPlanOutcome> StopBackupPlanOutcomeCallable;
typedef std::function<void(const DbsClient*, const Model::StopBackupPlanRequest&, const StopBackupPlanOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> StopBackupPlanAsyncHandler;
typedef Outcome<Error, Model::UpgradeBackupPlanResult> UpgradeBackupPlanOutcome;
typedef std::future<UpgradeBackupPlanOutcome> UpgradeBackupPlanOutcomeCallable;
typedef std::function<void(const DbsClient*, const Model::UpgradeBackupPlanRequest&, const UpgradeBackupPlanOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> UpgradeBackupPlanAsyncHandler;
DbsClient(const Credentials &credentials, const ClientConfiguration &configuration);
DbsClient(const std::shared_ptr<CredentialsProvider> &credentialsProvider, const ClientConfiguration &configuration);
DbsClient(const std::string &accessKeyId, const std::string &accessKeySecret, const ClientConfiguration &configuration);
~DbsClient();
DescribeBackupPlanListOutcome describeBackupPlanList(const Model::DescribeBackupPlanListRequest &request)const;
void describeBackupPlanListAsync(const Model::DescribeBackupPlanListRequest& request, const DescribeBackupPlanListAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeBackupPlanListOutcomeCallable describeBackupPlanListCallable(const Model::DescribeBackupPlanListRequest& request) const;
CreateBackupPlanOutcome createBackupPlan(const Model::CreateBackupPlanRequest &request)const;
void createBackupPlanAsync(const Model::CreateBackupPlanRequest& request, const CreateBackupPlanAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
CreateBackupPlanOutcomeCallable createBackupPlanCallable(const Model::CreateBackupPlanRequest& request) const;
StartBackupPlanOutcome startBackupPlan(const Model::StartBackupPlanRequest &request)const;
void startBackupPlanAsync(const Model::StartBackupPlanRequest& request, const StartBackupPlanAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
StartBackupPlanOutcomeCallable startBackupPlanCallable(const Model::StartBackupPlanRequest& request) const;
RenewBackupPlanOutcome renewBackupPlan(const Model::RenewBackupPlanRequest &request)const;
void renewBackupPlanAsync(const Model::RenewBackupPlanRequest& request, const RenewBackupPlanAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
RenewBackupPlanOutcomeCallable renewBackupPlanCallable(const Model::RenewBackupPlanRequest& request) const;
DescribeFullBackupListOutcome describeFullBackupList(const Model::DescribeFullBackupListRequest &request)const;
void describeFullBackupListAsync(const Model::DescribeFullBackupListRequest& request, const DescribeFullBackupListAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeFullBackupListOutcomeCallable describeFullBackupListCallable(const Model::DescribeFullBackupListRequest& request) const;
UpgradeBackupPlanOutcome upgradeBackupPlan(const Model::UpgradeBackupPlanRequest &request)const;
void upgradeBackupPlanAsync(const Model::UpgradeBackupPlanRequest& request, const UpgradeBackupPlanAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
UpgradeBackupPlanOutcomeCallable upgradeBackupPlanCallable(const Model::UpgradeBackupPlanRequest& request) const;
DescribeRestoreTaskListOutcome describeRestoreTaskList(const Model::DescribeRestoreTaskListRequest &request)const;
void describeRestoreTaskListAsync(const Model::DescribeRestoreTaskListRequest& request, const DescribeRestoreTaskListAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeRestoreTaskListOutcomeCallable describeRestoreTaskListCallable(const Model::DescribeRestoreTaskListRequest& request) const;
ModifyBackupPlanNameOutcome modifyBackupPlanName(const Model::ModifyBackupPlanNameRequest &request)const;
void modifyBackupPlanNameAsync(const Model::ModifyBackupPlanNameRequest& request, const ModifyBackupPlanNameAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
ModifyBackupPlanNameOutcomeCallable modifyBackupPlanNameCallable(const Model::ModifyBackupPlanNameRequest& request) const;
StopBackupPlanOutcome stopBackupPlan(const Model::StopBackupPlanRequest &request)const;
void stopBackupPlanAsync(const Model::StopBackupPlanRequest& request, const StopBackupPlanAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
StopBackupPlanOutcomeCallable stopBackupPlanCallable(const Model::StopBackupPlanRequest& request) const;
DescribeBackupGatewayListOutcome describeBackupGatewayList(const Model::DescribeBackupGatewayListRequest &request)const;
void describeBackupGatewayListAsync(const Model::DescribeBackupGatewayListRequest& request, const DescribeBackupGatewayListAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeBackupGatewayListOutcomeCallable describeBackupGatewayListCallable(const Model::DescribeBackupGatewayListRequest& request) const;
ModifyBackupSourceEndpointOutcome modifyBackupSourceEndpoint(const Model::ModifyBackupSourceEndpointRequest &request)const;
void modifyBackupSourceEndpointAsync(const Model::ModifyBackupSourceEndpointRequest& request, const ModifyBackupSourceEndpointAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
ModifyBackupSourceEndpointOutcomeCallable modifyBackupSourceEndpointCallable(const Model::ModifyBackupSourceEndpointRequest& request) const;
DescribePreCheckProgressListOutcome describePreCheckProgressList(const Model::DescribePreCheckProgressListRequest &request)const;
void describePreCheckProgressListAsync(const Model::DescribePreCheckProgressListRequest& request, const DescribePreCheckProgressListAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribePreCheckProgressListOutcomeCallable describePreCheckProgressListCallable(const Model::DescribePreCheckProgressListRequest& request) const;
ModifyBackupObjectsOutcome modifyBackupObjects(const Model::ModifyBackupObjectsRequest &request)const;
void modifyBackupObjectsAsync(const Model::ModifyBackupObjectsRequest& request, const ModifyBackupObjectsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
ModifyBackupObjectsOutcomeCallable modifyBackupObjectsCallable(const Model::ModifyBackupObjectsRequest& request) const;
DescribeIncrementBackupListOutcome describeIncrementBackupList(const Model::DescribeIncrementBackupListRequest &request)const;
void describeIncrementBackupListAsync(const Model::DescribeIncrementBackupListRequest& request, const DescribeIncrementBackupListAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeIncrementBackupListOutcomeCallable describeIncrementBackupListCallable(const Model::DescribeIncrementBackupListRequest& request) const;
CreateRestoreTaskOutcome createRestoreTask(const Model::CreateRestoreTaskRequest &request)const;
void createRestoreTaskAsync(const Model::CreateRestoreTaskRequest& request, const CreateRestoreTaskAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
CreateRestoreTaskOutcomeCallable createRestoreTaskCallable(const Model::CreateRestoreTaskRequest& request) const;
ConfigureBackupPlanOutcome configureBackupPlan(const Model::ConfigureBackupPlanRequest &request)const;
void configureBackupPlanAsync(const Model::ConfigureBackupPlanRequest& request, const ConfigureBackupPlanAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
ConfigureBackupPlanOutcomeCallable configureBackupPlanCallable(const Model::ConfigureBackupPlanRequest& request) const;
ModifyBackupStrategyOutcome modifyBackupStrategy(const Model::ModifyBackupStrategyRequest &request)const;
void modifyBackupStrategyAsync(const Model::ModifyBackupStrategyRequest& request, const ModifyBackupStrategyAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
ModifyBackupStrategyOutcomeCallable modifyBackupStrategyCallable(const Model::ModifyBackupStrategyRequest& request) const;
StartRestoreTaskOutcome startRestoreTask(const Model::StartRestoreTaskRequest &request)const;
void startRestoreTaskAsync(const Model::StartRestoreTaskRequest& request, const StartRestoreTaskAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
StartRestoreTaskOutcomeCallable startRestoreTaskCallable(const Model::StartRestoreTaskRequest& request) const;
CreateBackupPlanOutcome createBackupPlan(const Model::CreateBackupPlanRequest &request)const;
void createBackupPlanAsync(const Model::CreateBackupPlanRequest& request, const CreateBackupPlanAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
CreateBackupPlanOutcomeCallable createBackupPlanCallable(const Model::CreateBackupPlanRequest& request) const;
CreateRestoreTaskOutcome createRestoreTask(const Model::CreateRestoreTaskRequest &request)const;
void createRestoreTaskAsync(const Model::CreateRestoreTaskRequest& request, const CreateRestoreTaskAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
CreateRestoreTaskOutcomeCallable createRestoreTaskCallable(const Model::CreateRestoreTaskRequest& request) const;
DescribeBackupGatewayListOutcome describeBackupGatewayList(const Model::DescribeBackupGatewayListRequest &request)const;
void describeBackupGatewayListAsync(const Model::DescribeBackupGatewayListRequest& request, const DescribeBackupGatewayListAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeBackupGatewayListOutcomeCallable describeBackupGatewayListCallable(const Model::DescribeBackupGatewayListRequest& request) const;
DescribeBackupPlanListOutcome describeBackupPlanList(const Model::DescribeBackupPlanListRequest &request)const;
void describeBackupPlanListAsync(const Model::DescribeBackupPlanListRequest& request, const DescribeBackupPlanListAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeBackupPlanListOutcomeCallable describeBackupPlanListCallable(const Model::DescribeBackupPlanListRequest& request) const;
DescribeFullBackupListOutcome describeFullBackupList(const Model::DescribeFullBackupListRequest &request)const;
void describeFullBackupListAsync(const Model::DescribeFullBackupListRequest& request, const DescribeFullBackupListAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeFullBackupListOutcomeCallable describeFullBackupListCallable(const Model::DescribeFullBackupListRequest& request) const;
DescribeIncrementBackupListOutcome describeIncrementBackupList(const Model::DescribeIncrementBackupListRequest &request)const;
void describeIncrementBackupListAsync(const Model::DescribeIncrementBackupListRequest& request, const DescribeIncrementBackupListAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeIncrementBackupListOutcomeCallable describeIncrementBackupListCallable(const Model::DescribeIncrementBackupListRequest& request) const;
DescribeNodeCidrListOutcome describeNodeCidrList(const Model::DescribeNodeCidrListRequest &request)const;
void describeNodeCidrListAsync(const Model::DescribeNodeCidrListRequest& request, const DescribeNodeCidrListAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeNodeCidrListOutcomeCallable describeNodeCidrListCallable(const Model::DescribeNodeCidrListRequest& request) const;
DescribePreCheckProgressListOutcome describePreCheckProgressList(const Model::DescribePreCheckProgressListRequest &request)const;
void describePreCheckProgressListAsync(const Model::DescribePreCheckProgressListRequest& request, const DescribePreCheckProgressListAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribePreCheckProgressListOutcomeCallable describePreCheckProgressListCallable(const Model::DescribePreCheckProgressListRequest& request) const;
DescribeRestoreTaskListOutcome describeRestoreTaskList(const Model::DescribeRestoreTaskListRequest &request)const;
void describeRestoreTaskListAsync(const Model::DescribeRestoreTaskListRequest& request, const DescribeRestoreTaskListAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeRestoreTaskListOutcomeCallable describeRestoreTaskListCallable(const Model::DescribeRestoreTaskListRequest& request) const;
ModifyBackupObjectsOutcome modifyBackupObjects(const Model::ModifyBackupObjectsRequest &request)const;
void modifyBackupObjectsAsync(const Model::ModifyBackupObjectsRequest& request, const ModifyBackupObjectsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
ModifyBackupObjectsOutcomeCallable modifyBackupObjectsCallable(const Model::ModifyBackupObjectsRequest& request) const;
ModifyBackupPlanNameOutcome modifyBackupPlanName(const Model::ModifyBackupPlanNameRequest &request)const;
void modifyBackupPlanNameAsync(const Model::ModifyBackupPlanNameRequest& request, const ModifyBackupPlanNameAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
ModifyBackupPlanNameOutcomeCallable modifyBackupPlanNameCallable(const Model::ModifyBackupPlanNameRequest& request) const;
ModifyBackupSourceEndpointOutcome modifyBackupSourceEndpoint(const Model::ModifyBackupSourceEndpointRequest &request)const;
void modifyBackupSourceEndpointAsync(const Model::ModifyBackupSourceEndpointRequest& request, const ModifyBackupSourceEndpointAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
ModifyBackupSourceEndpointOutcomeCallable modifyBackupSourceEndpointCallable(const Model::ModifyBackupSourceEndpointRequest& request) const;
ModifyBackupStrategyOutcome modifyBackupStrategy(const Model::ModifyBackupStrategyRequest &request)const;
void modifyBackupStrategyAsync(const Model::ModifyBackupStrategyRequest& request, const ModifyBackupStrategyAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
ModifyBackupStrategyOutcomeCallable modifyBackupStrategyCallable(const Model::ModifyBackupStrategyRequest& request) const;
RenewBackupPlanOutcome renewBackupPlan(const Model::RenewBackupPlanRequest &request)const;
void renewBackupPlanAsync(const Model::RenewBackupPlanRequest& request, const RenewBackupPlanAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
RenewBackupPlanOutcomeCallable renewBackupPlanCallable(const Model::RenewBackupPlanRequest& request) const;
StartBackupPlanOutcome startBackupPlan(const Model::StartBackupPlanRequest &request)const;
void startBackupPlanAsync(const Model::StartBackupPlanRequest& request, const StartBackupPlanAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
StartBackupPlanOutcomeCallable startBackupPlanCallable(const Model::StartBackupPlanRequest& request) const;
StartRestoreTaskOutcome startRestoreTask(const Model::StartRestoreTaskRequest &request)const;
void startRestoreTaskAsync(const Model::StartRestoreTaskRequest& request, const StartRestoreTaskAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
StartRestoreTaskOutcomeCallable startRestoreTaskCallable(const Model::StartRestoreTaskRequest& request) const;
StopBackupPlanOutcome stopBackupPlan(const Model::StopBackupPlanRequest &request)const;
void stopBackupPlanAsync(const Model::StopBackupPlanRequest& request, const StopBackupPlanAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
StopBackupPlanOutcomeCallable stopBackupPlanCallable(const Model::StopBackupPlanRequest& request) const;
UpgradeBackupPlanOutcome upgradeBackupPlan(const Model::UpgradeBackupPlanRequest &request)const;
void upgradeBackupPlanAsync(const Model::UpgradeBackupPlanRequest& request, const UpgradeBackupPlanAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
UpgradeBackupPlanOutcomeCallable upgradeBackupPlanCallable(const Model::UpgradeBackupPlanRequest& request) const;
private:
std::shared_ptr<EndpointProvider> endpointProvider_;

45
dbs/include/alibabacloud/dbs/model/ConfigureBackupPlanRequest.h
View File

@@ -37,8 +37,6 @@ namespace AlibabaCloud
std::string getSourceEndpointRegion()const;
void setSourceEndpointRegion(const std::string& sourceEndpointRegion);
int getDuplicationArchivePeriod()const;
void setDuplicationArchivePeriod(int duplicationArchivePeriod);
long getBackupGatewayId()const;
void setBackupGatewayId(long backupGatewayId);
std::string getSourceEndpointInstanceID()const;
@@ -47,65 +45,64 @@ namespace AlibabaCloud
void setSourceEndpointUserName(const std::string& sourceEndpointUserName);
std::string getClientToken()const;
void setClientToken(const std::string& clientToken);
std::string getSourceEndpointPassword()const;
void setSourceEndpointPassword(const std::string& sourceEndpointPassword);
std::string getBackupPlanId()const;
void setBackupPlanId(const std::string& backupPlanId);
std::string getSourceEndpointDatabaseName()const;
void setSourceEndpointDatabaseName(const std::string& sourceEndpointDatabaseName);
int getDuplicationInfrequentAccessPeriod()const;
void setDuplicationInfrequentAccessPeriod(int duplicationInfrequentAccessPeriod);
std::string getBackupStartTime()const;
void setBackupStartTime(const std::string& backupStartTime);
std::string getSourceEndpointIP()const;
void setSourceEndpointIP(const std::string& sourceEndpointIP);
bool getEnableBackupLog()const;
void setEnableBackupLog(bool enableBackupLog);
int getDuplicationArchivePeriod()const;
void setDuplicationArchivePeriod(int duplicationArchivePeriod);
std::string getSourceEndpointPassword()const;
void setSourceEndpointPassword(const std::string& sourceEndpointPassword);
std::string getBackupObjects()const;
void setBackupObjects(const std::string& backupObjects);
std::string getOwnerId()const;
void setOwnerId(const std::string& ownerId);
int getSourceEndpointPort()const;
void setSourceEndpointPort(int sourceEndpointPort);
std::string getSourceEndpointDatabaseName()const;
void setSourceEndpointDatabaseName(const std::string& sourceEndpointDatabaseName);
int getBackupRetentionPeriod()const;
void setBackupRetentionPeriod(int backupRetentionPeriod);
int getDuplicationInfrequentAccessPeriod()const;
void setDuplicationInfrequentAccessPeriod(int duplicationInfrequentAccessPeriod);
std::string getBackupPeriod()const;
void setBackupPeriod(const std::string& backupPeriod);
std::string getBackupStartTime()const;
void setBackupStartTime(const std::string& backupStartTime);
std::string getSourceEndpointInstanceType()const;
void setSourceEndpointInstanceType(const std::string& sourceEndpointInstanceType);
std::string getSourceEndpointIP()const;
void setSourceEndpointIP(const std::string& sourceEndpointIP);
std::string getBackupPlanName()const;
void setBackupPlanName(const std::string& backupPlanName);
std::string getRegionId()const;
void setRegionId(const std::string& regionId);
std::string getSourceEndpointOracleSID()const;
void setSourceEndpointOracleSID(const std::string& sourceEndpointOracleSID);
std::string getOSSBucketName()const;
void setOSSBucketName(const std::string& oSSBucketName);
bool getEnableBackupLog()const;
void setEnableBackupLog(bool enableBackupLog);
private:
std::string sourceEndpointRegion_;
int duplicationArchivePeriod_;
long backupGatewayId_;
std::string sourceEndpointInstanceID_;
std::string sourceEndpointUserName_;
std::string clientToken_;
std::string sourceEndpointPassword_;
std::string backupPlanId_;
std::string sourceEndpointDatabaseName_;
int duplicationInfrequentAccessPeriod_;
std::string backupStartTime_;
std::string sourceEndpointIP_;
bool enableBackupLog_;
int duplicationArchivePeriod_;
std::string sourceEndpointPassword_;
std::string backupObjects_;
std::string ownerId_;
int sourceEndpointPort_;
std::string sourceEndpointDatabaseName_;
int backupRetentionPeriod_;
int duplicationInfrequentAccessPeriod_;
std::string backupPeriod_;
std::string backupStartTime_;
std::string sourceEndpointInstanceType_;
std::string sourceEndpointIP_;
std::string backupPlanName_;
std::string regionId_;
std::string sourceEndpointOracleSID_;
std::string oSSBucketName_;
bool enableBackupLog_;
};
}

33
dbs/include/alibabacloud/dbs/model/CreateBackupPlanRequest.h
View File

@@ -37,28 +37,26 @@ namespace AlibabaCloud
std::string getDatabaseType()const;
void setDatabaseType(const std::string& databaseType);
std::string getPeriod()const;
void setPeriod(const std::string& period);
std::string getClientToken()const;
void setClientToken(const std::string& clientToken);
std::string getOwnerId()const;
void setOwnerId(const std::string& ownerId);
int getUsedTime()const;
void setUsedTime(int usedTime);
std::string getInstanceClass()const;
void setInstanceClass(const std::string& instanceClass);
std::string getStorageType()const;
void setStorageType(const std::string& storageType);
std::string getBackupMethod()const;
void setBackupMethod(const std::string& backupMethod);
std::string getDatabaseRegion()const;
void setDatabaseRegion(const std::string& databaseRegion);
std::string getStorageRegion()const;
void setStorageRegion(const std::string& storageRegion);
std::string getRegionId()const;
void setRegionId(const std::string& regionId);
std::string getInstanceType()const;
void setInstanceType(const std::string& instanceType);
std::string getPeriod()const;
void setPeriod(const std::string& period);
std::string getOwnerId()const;
void setOwnerId(const std::string& ownerId);
int getUsedTime()const;
void setUsedTime(int usedTime);
std::string getBackupMethod()const;
void setBackupMethod(const std::string& backupMethod);
std::string getStorageRegion()const;
void setStorageRegion(const std::string& storageRegion);
std::string getRegion()const;
void setRegion(const std::string& region);
std::string getPayType()const;
@@ -66,17 +64,16 @@ namespace AlibabaCloud
private:
std::string databaseType_;
std::string period_;
std::string clientToken_;
std::string ownerId_;
int usedTime_;
std::string instanceClass_;
std::string storageType_;
std::string backupMethod_;
std::string databaseRegion_;
std::string storageRegion_;
std::string regionId_;
std::string instanceType_;
std::string period_;
std::string ownerId_;
int usedTime_;
std::string backupMethod_;
std::string storageRegion_;
std::string region_;
std::string payType_;

57
dbs/include/alibabacloud/dbs/model/CreateRestoreTaskRequest.h
View File

@@ -37,40 +37,38 @@ namespace AlibabaCloud
long getBackupGatewayId()const;
void setBackupGatewayId(long backupGatewayId);
std::string getDestinationEndpointOracleSID()const;
void setDestinationEndpointOracleSID(const std::string& destinationEndpointOracleSID);
long getRestoreTime()const;
void setRestoreTime(long restoreTime);
std::string getDestinationEndpointInstanceType()const;
void setDestinationEndpointInstanceType(const std::string& destinationEndpointInstanceType);
std::string getClientToken()const;
void setClientToken(const std::string& clientToken);
std::string getDestinationEndpointInstanceID()const;
void setDestinationEndpointInstanceID(const std::string& destinationEndpointInstanceID);
int getDestinationEndpointPort()const;
void setDestinationEndpointPort(int destinationEndpointPort);
std::string getBackupPlanId()const;
void setBackupPlanId(const std::string& backupPlanId);
std::string getBackupSetId()const;
void setBackupSetId(const std::string& backupSetId);
std::string getOwnerId()const;
void setOwnerId(const std::string& ownerId);
std::string getDestinationEndpointRegion()const;
void setDestinationEndpointRegion(const std::string& destinationEndpointRegion);
std::string getRestoreDir()const;
void setRestoreDir(const std::string& restoreDir);
std::string getDestinationEndpointIP()const;
void setDestinationEndpointIP(const std::string& destinationEndpointIP);
std::string getRegionId()const;
void setRegionId(const std::string& regionId);
std::string getDestinationEndpointDatabaseName()const;
void setDestinationEndpointDatabaseName(const std::string& destinationEndpointDatabaseName);
std::string getDestinationEndpointUserName()const;
void setDestinationEndpointUserName(const std::string& destinationEndpointUserName);
std::string getRestoreObjects()const;
void setRestoreObjects(const std::string& restoreObjects);
std::string getRestoreTaskName()const;
void setRestoreTaskName(const std::string& restoreTaskName);
std::string getDestinationEndpointOracleSID()const;
void setDestinationEndpointOracleSID(const std::string& destinationEndpointOracleSID);
long getRestoreTime()const;
void setRestoreTime(long restoreTime);
std::string getDestinationEndpointInstanceID()const;
void setDestinationEndpointInstanceID(const std::string& destinationEndpointInstanceID);
int getDestinationEndpointPort()const;
void setDestinationEndpointPort(int destinationEndpointPort);
std::string getBackupSetId()const;
void setBackupSetId(const std::string& backupSetId);
std::string getOwnerId()const;
void setOwnerId(const std::string& ownerId);
std::string getRestoreDir()const;
void setRestoreDir(const std::string& restoreDir);
std::string getDestinationEndpointIP()const;
void setDestinationEndpointIP(const std::string& destinationEndpointIP);
std::string getDestinationEndpointDatabaseName()const;
void setDestinationEndpointDatabaseName(const std::string& destinationEndpointDatabaseName);
std::string getDuplicateConflict()const;
void setDuplicateConflict(const std::string& duplicateConflict);
std::string getDestinationEndpointPassword()const;
@@ -78,23 +76,22 @@ namespace AlibabaCloud
private:
long backupGatewayId_;
std::string destinationEndpointOracleSID_;
long restoreTime_;
std::string destinationEndpointInstanceType_;
std::string clientToken_;
std::string destinationEndpointInstanceID_;
int destinationEndpointPort_;
std::string backupPlanId_;
std::string backupSetId_;
std::string ownerId_;
std::string destinationEndpointRegion_;
std::string restoreDir_;
std::string destinationEndpointIP_;
std::string regionId_;
std::string destinationEndpointDatabaseName_;
std::string destinationEndpointUserName_;
std::string restoreObjects_;
std::string restoreTaskName_;
std::string destinationEndpointOracleSID_;
long restoreTime_;
std::string destinationEndpointInstanceID_;
int destinationEndpointPort_;
std::string backupSetId_;
std::string ownerId_;
std::string restoreDir_;
std::string destinationEndpointIP_;
std::string destinationEndpointDatabaseName_;
std::string duplicateConflict_;
std::string destinationEndpointPassword_;

15
dbs/include/alibabacloud/dbs/model/DescribeBackupGatewayListRequest.h
View File

@@ -37,27 +37,24 @@ namespace AlibabaCloud
std::string getIdentifier()const;
void setIdentifier(const std::string& identifier);
std::string getRegionId()const;
void setRegionId(const std::string& regionId);
std::string getClientToken()const;
void setClientToken(const std::string& clientToken);
int getPageSize()const;
void setPageSize(int pageSize);
std::string getRegion()const;
void setRegion(const std::string& region);
int getPageNum()const;
void setPageNum(int pageNum);
std::string getOwnerId()const;
void setOwnerId(const std::string& ownerId);
int getPageSize()const;
void setPageSize(int pageSize);
std::string getRegion()const;
void setRegion(const std::string& region);
private:
std::string identifier_;
std::string regionId_;
std::string clientToken_;
int pageSize_;
std::string region_;
int pageNum_;
std::string ownerId_;
int pageSize_;
std::string region_;
};
}

15
dbs/include/alibabacloud/dbs/model/DescribeBackupPlanListRequest.h
View File

@@ -35,29 +35,26 @@ namespace AlibabaCloud
DescribeBackupPlanListRequest();
~DescribeBackupPlanListRequest();
std::string getRegionId()const;
void setRegionId(const std::string& regionId);
std::string getClientToken()const;
void setClientToken(const std::string& clientToken);
int getPageSize()const;
void setPageSize(int pageSize);
std::string getBackupPlanId()const;
void setBackupPlanId(const std::string& backupPlanId);
std::string getRegion()const;
void setRegion(const std::string& region);
int getPageNum()const;
void setPageNum(int pageNum);
std::string getOwnerId()const;
void setOwnerId(const std::string& ownerId);
int getPageSize()const;
void setPageSize(int pageSize);
std::string getRegion()const;
void setRegion(const std::string& region);
private:
std::string regionId_;
std::string clientToken_;
int pageSize_;
std::string backupPlanId_;
std::string region_;
int pageNum_;
std::string ownerId_;
int pageSize_;
std::string region_;
};
}

9
dbs/include/alibabacloud/dbs/model/DescribeFullBackupListRequest.h
View File

@@ -35,26 +35,23 @@ namespace AlibabaCloud
DescribeFullBackupListRequest();
~DescribeFullBackupListRequest();
std::string getRegionId()const;
void setRegionId(const std::string& regionId);
std::string getClientToken()const;
void setClientToken(const std::string& clientToken);
int getPageSize()const;
void setPageSize(int pageSize);
std::string getBackupPlanId()const;
void setBackupPlanId(const std::string& backupPlanId);
int getPageNum()const;
void setPageNum(int pageNum);
std::string getOwnerId()const;
void setOwnerId(const std::string& ownerId);
int getPageSize()const;
void setPageSize(int pageSize);
private:
std::string regionId_;
std::string clientToken_;
int pageSize_;
std::string backupPlanId_;
int pageNum_;
std::string ownerId_;
int pageSize_;
};
}

9
dbs/include/alibabacloud/dbs/model/DescribeIncrementBackupListRequest.h
View File

@@ -35,26 +35,23 @@ namespace AlibabaCloud
DescribeIncrementBackupListRequest();
~DescribeIncrementBackupListRequest();
std::string getRegionId()const;
void setRegionId(const std::string& regionId);
std::string getClientToken()const;
void setClientToken(const std::string& clientToken);
int getPageSize()const;
void setPageSize(int pageSize);
std::string getBackupPlanId()const;
void setBackupPlanId(const std::string& backupPlanId);
int getPageNum()const;
void setPageNum(int pageNum);
std::string getOwnerId()const;
void setOwnerId(const std::string& ownerId);
int getPageSize()const;
void setPageSize(int pageSize);
private:
std::string regionId_;
std::string clientToken_;
int pageSize_;
std::string backupPlanId_;
int pageNum_;
std::string ownerId_;
int pageSize_;
};
}

9
dbs/include/alibabacloud/dbs/model/DescribeNodeCidrListRequest.h
View File

@@ -35,20 +35,17 @@ namespace AlibabaCloud
DescribeNodeCidrListRequest();
~DescribeNodeCidrListRequest();
std::string getRegionId()const;
void setRegionId(const std::string& regionId);
std::string getClientToken()const;
void setClientToken(const std::string& clientToken);
std::string getRegion()const;
void setRegion(const std::string& region);
std::string getOwnerId()const;
void setOwnerId(const std::string& ownerId);
std::string getRegion()const;
void setRegion(const std::string& region);
private:
std::string regionId_;
std::string clientToken_;
std::string region_;
std::string ownerId_;
std::string region_;
};
}

9
dbs/include/alibabacloud/dbs/model/DescribePreCheckProgressListRequest.h
View File

@@ -35,23 +35,20 @@ namespace AlibabaCloud
DescribePreCheckProgressListRequest();
~DescribePreCheckProgressListRequest();
std::string getRegionId()const;
void setRegionId(const std::string& regionId);
std::string getClientToken()const;
void setClientToken(const std::string& clientToken);
std::string getRestoreTaskId()const;
void setRestoreTaskId(const std::string& restoreTaskId);
std::string getBackupPlanId()const;
void setBackupPlanId(const std::string& backupPlanId);
std::string getOwnerId()const;
void setOwnerId(const std::string& ownerId);
std::string getRestoreTaskId()const;
void setRestoreTaskId(const std::string& restoreTaskId);
private:
std::string regionId_;
std::string clientToken_;
std::string restoreTaskId_;
std::string backupPlanId_;
std::string ownerId_;
std::string restoreTaskId_;
};
}

15
dbs/include/alibabacloud/dbs/model/DescribeRestoreTaskListRequest.h
View File

@@ -35,29 +35,26 @@ namespace AlibabaCloud
DescribeRestoreTaskListRequest();
~DescribeRestoreTaskListRequest();
std::string getRegionId()const;
void setRegionId(const std::string& regionId);
std::string getClientToken()const;
void setClientToken(const std::string& clientToken);
std::string getRestoreTaskId()const;
void setRestoreTaskId(const std::string& restoreTaskId);
int getPageSize()const;
void setPageSize(int pageSize);
std::string getBackupPlanId()const;
void setBackupPlanId(const std::string& backupPlanId);
int getPageNum()const;
void setPageNum(int pageNum);
std::string getOwnerId()const;
void setOwnerId(const std::string& ownerId);
std::string getRestoreTaskId()const;
void setRestoreTaskId(const std::string& restoreTaskId);
int getPageSize()const;
void setPageSize(int pageSize);
private:
std::string regionId_;
std::string clientToken_;
std::string restoreTaskId_;
int pageSize_;
std::string backupPlanId_;
int pageNum_;
std::string ownerId_;
std::string restoreTaskId_;
int pageSize_;
};
}

3
dbs/include/alibabacloud/dbs/model/ModifyBackupObjectsRequest.h
View File

@@ -35,8 +35,6 @@ namespace AlibabaCloud
ModifyBackupObjectsRequest();
~ModifyBackupObjectsRequest();
std::string getRegionId()const;
void setRegionId(const std::string& regionId);
std::string getClientToken()const;
void setClientToken(const std::string& clientToken);
std::string getBackupPlanId()const;
@@ -47,7 +45,6 @@ namespace AlibabaCloud
void setOwnerId(const std::string& ownerId);
private:
std::string regionId_;
std::string clientToken_;
std::string backupPlanId_;
std::string backupObjects_;

9
dbs/include/alibabacloud/dbs/model/ModifyBackupPlanNameRequest.h
View File

@@ -35,23 +35,20 @@ namespace AlibabaCloud
ModifyBackupPlanNameRequest();
~ModifyBackupPlanNameRequest();
std::string getBackupPlanName()const;
void setBackupPlanName(const std::string& backupPlanName);
std::string getRegionId()const;
void setRegionId(const std::string& regionId);
std::string getClientToken()const;
void setClientToken(const std::string& clientToken);
std::string getBackupPlanId()const;
void setBackupPlanId(const std::string& backupPlanId);
std::string getOwnerId()const;
void setOwnerId(const std::string& ownerId);
std::string getBackupPlanName()const;
void setBackupPlanName(const std::string& backupPlanName);
private:
std::string backupPlanName_;
std::string regionId_;
std::string clientToken_;
std::string backupPlanId_;
std::string ownerId_;
std::string backupPlanName_;
};
}

21
dbs/include/alibabacloud/dbs/model/ModifyBackupSourceEndpointRequest.h
View File

@@ -45,24 +45,22 @@ namespace AlibabaCloud
void setSourceEndpointUserName(const std::string& sourceEndpointUserName);
std::string getClientToken()const;
void setClientToken(const std::string& clientToken);
std::string getSourceEndpointPassword()const;
void setSourceEndpointPassword(const std::string& sourceEndpointPassword);
std::string getBackupPlanId()const;
void setBackupPlanId(const std::string& backupPlanId);
std::string getSourceEndpointDatabaseName()const;
void setSourceEndpointDatabaseName(const std::string& sourceEndpointDatabaseName);
std::string getSourceEndpointIP()const;
void setSourceEndpointIP(const std::string& sourceEndpointIP);
std::string getSourceEndpointPassword()const;
void setSourceEndpointPassword(const std::string& sourceEndpointPassword);
std::string getBackupObjects()const;
void setBackupObjects(const std::string& backupObjects);
std::string getOwnerId()const;
void setOwnerId(const std::string& ownerId);
int getSourceEndpointPort()const;
void setSourceEndpointPort(int sourceEndpointPort);
std::string getSourceEndpointDatabaseName()const;
void setSourceEndpointDatabaseName(const std::string& sourceEndpointDatabaseName);
std::string getSourceEndpointInstanceType()const;
void setSourceEndpointInstanceType(const std::string& sourceEndpointInstanceType);
std::string getSourceEndpointIP()const;
void setSourceEndpointIP(const std::string& sourceEndpointIP);
std::string getRegionId()const;
void setRegionId(const std::string& regionId);
std::string getSourceEndpointOracleSID()const;
void setSourceEndpointOracleSID(const std::string& sourceEndpointOracleSID);
@@ -72,15 +70,14 @@ namespace AlibabaCloud
std::string sourceEndpointInstanceID_;
std::string sourceEndpointUserName_;
std::string clientToken_;
std::string sourceEndpointPassword_;
std::string backupPlanId_;
std::string sourceEndpointDatabaseName_;
std::string sourceEndpointIP_;
std::string sourceEndpointPassword_;
std::string backupObjects_;
std::string ownerId_;
int sourceEndpointPort_;
std::string sourceEndpointDatabaseName_;
std::string sourceEndpointInstanceType_;
std::string sourceEndpointIP_;
std::string regionId_;
std::string sourceEndpointOracleSID_;
};

15
dbs/include/alibabacloud/dbs/model/ModifyBackupStrategyRequest.h
View File

@@ -35,26 +35,23 @@ namespace AlibabaCloud
ModifyBackupStrategyRequest();
~ModifyBackupStrategyRequest();
std::string getBackupPeriod()const;
void setBackupPeriod(const std::string& backupPeriod);
std::string getBackupStartTime()const;
void setBackupStartTime(const std::string& backupStartTime);
std::string getRegionId()const;
void setRegionId(const std::string& regionId);
std::string getClientToken()const;
void setClientToken(const std::string& clientToken);
std::string getBackupPlanId()const;
void setBackupPlanId(const std::string& backupPlanId);
std::string getOwnerId()const;
void setOwnerId(const std::string& ownerId);
std::string getBackupPeriod()const;
void setBackupPeriod(const std::string& backupPeriod);
std::string getBackupStartTime()const;
void setBackupStartTime(const std::string& backupStartTime);
private:
std::string backupPeriod_;
std::string backupStartTime_;
std::string regionId_;
std::string clientToken_;
std::string backupPlanId_;
std::string ownerId_;
std::string backupPeriod_;
std::string backupStartTime_;
};
}

3
dbs/include/alibabacloud/dbs/model/RenewBackupPlanRequest.h
View File

@@ -37,8 +37,6 @@ namespace AlibabaCloud
std::string getPeriod()const;
void setPeriod(const std::string& period);
std::string getRegionId()const;
void setRegionId(const std::string& regionId);
std::string getClientToken()const;
void setClientToken(const std::string& clientToken);
std::string getBackupPlanId()const;
@@ -50,7 +48,6 @@ namespace AlibabaCloud
private:
std::string period_;
std::string regionId_;
std::string clientToken_;
std::string backupPlanId_;
std::string ownerId_;

3
dbs/include/alibabacloud/dbs/model/StartBackupPlanRequest.h
View File

@@ -35,8 +35,6 @@ namespace AlibabaCloud
StartBackupPlanRequest();
~StartBackupPlanRequest();
std::string getRegionId()const;
void setRegionId(const std::string& regionId);
std::string getClientToken()const;
void setClientToken(const std::string& clientToken);
std::string getBackupPlanId()const;
@@ -45,7 +43,6 @@ namespace AlibabaCloud
void setOwnerId(const std::string& ownerId);
private:
std::string regionId_;
std::string clientToken_;
std::string backupPlanId_;
std::string ownerId_;

9
dbs/include/alibabacloud/dbs/model/StartRestoreTaskRequest.h
View File

@@ -35,20 +35,17 @@ namespace AlibabaCloud
StartRestoreTaskRequest();
~StartRestoreTaskRequest();
std::string getRegionId()const;
void setRegionId(const std::string& regionId);
std::string getClientToken()const;
void setClientToken(const std::string& clientToken);
std::string getRestoreTaskId()const;
void setRestoreTaskId(const std::string& restoreTaskId);
std::string getOwnerId()const;
void setOwnerId(const std::string& ownerId);
std::string getRestoreTaskId()const;
void setRestoreTaskId(const std::string& restoreTaskId);
private:
std::string regionId_;
std::string clientToken_;
std::string restoreTaskId_;
std::string ownerId_;
std::string restoreTaskId_;
};
}

3
dbs/include/alibabacloud/dbs/model/StopBackupPlanRequest.h
View File

@@ -37,8 +37,6 @@ namespace AlibabaCloud
std::string getStopMethod()const;
void setStopMethod(const std::string& stopMethod);
std::string getRegionId()const;
void setRegionId(const std::string& regionId);
std::string getClientToken()const;
void setClientToken(const std::string& clientToken);
std::string getBackupPlanId()const;
@@ -48,7 +46,6 @@ namespace AlibabaCloud
private:
std::string stopMethod_;
std::string regionId_;
std::string clientToken_;
std::string backupPlanId_;
std::string ownerId_;

3
dbs/include/alibabacloud/dbs/model/UpgradeBackupPlanRequest.h
View File

@@ -35,8 +35,6 @@ namespace AlibabaCloud
UpgradeBackupPlanRequest();
~UpgradeBackupPlanRequest();
std::string getRegionId()const;
void setRegionId(const std::string& regionId);
std::string getClientToken()const;
void setClientToken(const std::string& clientToken);
std::string getBackupPlanId()const;
@@ -47,7 +45,6 @@ namespace AlibabaCloud
void setInstanceClass(const std::string& instanceClass);
private:
std::string regionId_;
std::string clientToken_;
std::string backupPlanId_;
std::string ownerId_;

636
dbs/src/DbsClient.cc
View File

@@ -31,56 +31,56 @@ DbsClient::DbsClient(const Credentials &credentials, const ClientConfiguration &
RpcServiceClient(SERVICE_NAME, std::make_shared<SimpleCredentialsProvider>(credentials), configuration)
{
auto locationClient = std::make_shared<LocationClient>(credentials, configuration);
endpointProvider_ = std::make_shared<EndpointProvider>(locationClient, configuration.regionId(), SERVICE_NAME, "cbs");
endpointProvider_ = std::make_shared<EndpointProvider>(locationClient, configuration.regionId(), SERVICE_NAME, "dbs");
}
DbsClient::DbsClient(const std::shared_ptr<CredentialsProvider>& credentialsProvider, const ClientConfiguration & configuration) :
RpcServiceClient(SERVICE_NAME, credentialsProvider, configuration)
{
auto locationClient = std::make_shared<LocationClient>(credentialsProvider, configuration);
endpointProvider_ = std::make_shared<EndpointProvider>(locationClient, configuration.regionId(), SERVICE_NAME, "cbs");
endpointProvider_ = std::make_shared<EndpointProvider>(locationClient, configuration.regionId(), SERVICE_NAME, "dbs");
}
DbsClient::DbsClient(const std::string & accessKeyId, const std::string & accessKeySecret, const ClientConfiguration & configuration) :
RpcServiceClient(SERVICE_NAME, std::make_shared<SimpleCredentialsProvider>(accessKeyId, accessKeySecret), configuration)
{
auto locationClient = std::make_shared<LocationClient>(accessKeyId, accessKeySecret, configuration);
endpointProvider_ = std::make_shared<EndpointProvider>(locationClient, configuration.regionId(), SERVICE_NAME, "cbs");
endpointProvider_ = std::make_shared<EndpointProvider>(locationClient, configuration.regionId(), SERVICE_NAME, "dbs");
}
DbsClient::~DbsClient()
{}
DbsClient::DescribeBackupPlanListOutcome DbsClient::describeBackupPlanList(const DescribeBackupPlanListRequest &request) const
DbsClient::ConfigureBackupPlanOutcome DbsClient::configureBackupPlan(const ConfigureBackupPlanRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return DescribeBackupPlanListOutcome(endpointOutcome.error());
return ConfigureBackupPlanOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return DescribeBackupPlanListOutcome(DescribeBackupPlanListResult(outcome.result()));
return ConfigureBackupPlanOutcome(ConfigureBackupPlanResult(outcome.result()));
else
return DescribeBackupPlanListOutcome(outcome.error());
return ConfigureBackupPlanOutcome(outcome.error());
}
void DbsClient::describeBackupPlanListAsync(const DescribeBackupPlanListRequest& request, const DescribeBackupPlanListAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
void DbsClient::configureBackupPlanAsync(const ConfigureBackupPlanRequest& request, const ConfigureBackupPlanAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, describeBackupPlanList(request), context);
handler(this, request, configureBackupPlan(request), context);
};
asyncExecute(new Runnable(fn));
}
DbsClient::DescribeBackupPlanListOutcomeCallable DbsClient::describeBackupPlanListCallable(const DescribeBackupPlanListRequest &request) const
DbsClient::ConfigureBackupPlanOutcomeCallable DbsClient::configureBackupPlanCallable(const ConfigureBackupPlanRequest &request) const
{
auto task = std::make_shared<std::packaged_task<DescribeBackupPlanListOutcome()>>(
auto task = std::make_shared<std::packaged_task<ConfigureBackupPlanOutcome()>>(
[this, request]()
{
return this->describeBackupPlanList(request);
return this->configureBackupPlan(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
@@ -123,252 +123,36 @@ DbsClient::CreateBackupPlanOutcomeCallable DbsClient::createBackupPlanCallable(c
return task->get_future();
}
DbsClient::StartBackupPlanOutcome DbsClient::startBackupPlan(const StartBackupPlanRequest &request) const
DbsClient::CreateRestoreTaskOutcome DbsClient::createRestoreTask(const CreateRestoreTaskRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return StartBackupPlanOutcome(endpointOutcome.error());
return CreateRestoreTaskOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return StartBackupPlanOutcome(StartBackupPlanResult(outcome.result()));
return CreateRestoreTaskOutcome(CreateRestoreTaskResult(outcome.result()));
else
return StartBackupPlanOutcome(outcome.error());
return CreateRestoreTaskOutcome(outcome.error());
}
void DbsClient::startBackupPlanAsync(const StartBackupPlanRequest& request, const StartBackupPlanAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
void DbsClient::createRestoreTaskAsync(const CreateRestoreTaskRequest& request, const CreateRestoreTaskAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, startBackupPlan(request), context);
handler(this, request, createRestoreTask(request), context);
};
asyncExecute(new Runnable(fn));
}
DbsClient::StartBackupPlanOutcomeCallable DbsClient::startBackupPlanCallable(const StartBackupPlanRequest &request) const
DbsClient::CreateRestoreTaskOutcomeCallable DbsClient::createRestoreTaskCallable(const CreateRestoreTaskRequest &request) const
{
auto task = std::make_shared<std::packaged_task<StartBackupPlanOutcome()>>(
auto task = std::make_shared<std::packaged_task<CreateRestoreTaskOutcome()>>(
[this, request]()
{
return this->startBackupPlan(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
DbsClient::RenewBackupPlanOutcome DbsClient::renewBackupPlan(const RenewBackupPlanRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return RenewBackupPlanOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return RenewBackupPlanOutcome(RenewBackupPlanResult(outcome.result()));
else
return RenewBackupPlanOutcome(outcome.error());
}
void DbsClient::renewBackupPlanAsync(const RenewBackupPlanRequest& request, const RenewBackupPlanAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, renewBackupPlan(request), context);
};
asyncExecute(new Runnable(fn));
}
DbsClient::RenewBackupPlanOutcomeCallable DbsClient::renewBackupPlanCallable(const RenewBackupPlanRequest &request) const
{
auto task = std::make_shared<std::packaged_task<RenewBackupPlanOutcome()>>(
[this, request]()
{
return this->renewBackupPlan(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
DbsClient::DescribeFullBackupListOutcome DbsClient::describeFullBackupList(const DescribeFullBackupListRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return DescribeFullBackupListOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return DescribeFullBackupListOutcome(DescribeFullBackupListResult(outcome.result()));
else
return DescribeFullBackupListOutcome(outcome.error());
}
void DbsClient::describeFullBackupListAsync(const DescribeFullBackupListRequest& request, const DescribeFullBackupListAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, describeFullBackupList(request), context);
};
asyncExecute(new Runnable(fn));
}
DbsClient::DescribeFullBackupListOutcomeCallable DbsClient::describeFullBackupListCallable(const DescribeFullBackupListRequest &request) const
{
auto task = std::make_shared<std::packaged_task<DescribeFullBackupListOutcome()>>(
[this, request]()
{
return this->describeFullBackupList(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
DbsClient::UpgradeBackupPlanOutcome DbsClient::upgradeBackupPlan(const UpgradeBackupPlanRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return UpgradeBackupPlanOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return UpgradeBackupPlanOutcome(UpgradeBackupPlanResult(outcome.result()));
else
return UpgradeBackupPlanOutcome(outcome.error());
}
void DbsClient::upgradeBackupPlanAsync(const UpgradeBackupPlanRequest& request, const UpgradeBackupPlanAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, upgradeBackupPlan(request), context);
};
asyncExecute(new Runnable(fn));
}
DbsClient::UpgradeBackupPlanOutcomeCallable DbsClient::upgradeBackupPlanCallable(const UpgradeBackupPlanRequest &request) const
{
auto task = std::make_shared<std::packaged_task<UpgradeBackupPlanOutcome()>>(
[this, request]()
{
return this->upgradeBackupPlan(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
DbsClient::DescribeRestoreTaskListOutcome DbsClient::describeRestoreTaskList(const DescribeRestoreTaskListRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return DescribeRestoreTaskListOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return DescribeRestoreTaskListOutcome(DescribeRestoreTaskListResult(outcome.result()));
else
return DescribeRestoreTaskListOutcome(outcome.error());
}
void DbsClient::describeRestoreTaskListAsync(const DescribeRestoreTaskListRequest& request, const DescribeRestoreTaskListAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, describeRestoreTaskList(request), context);
};
asyncExecute(new Runnable(fn));
}
DbsClient::DescribeRestoreTaskListOutcomeCallable DbsClient::describeRestoreTaskListCallable(const DescribeRestoreTaskListRequest &request) const
{
auto task = std::make_shared<std::packaged_task<DescribeRestoreTaskListOutcome()>>(
[this, request]()
{
return this->describeRestoreTaskList(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
DbsClient::ModifyBackupPlanNameOutcome DbsClient::modifyBackupPlanName(const ModifyBackupPlanNameRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return ModifyBackupPlanNameOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return ModifyBackupPlanNameOutcome(ModifyBackupPlanNameResult(outcome.result()));
else
return ModifyBackupPlanNameOutcome(outcome.error());
}
void DbsClient::modifyBackupPlanNameAsync(const ModifyBackupPlanNameRequest& request, const ModifyBackupPlanNameAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, modifyBackupPlanName(request), context);
};
asyncExecute(new Runnable(fn));
}
DbsClient::ModifyBackupPlanNameOutcomeCallable DbsClient::modifyBackupPlanNameCallable(const ModifyBackupPlanNameRequest &request) const
{
auto task = std::make_shared<std::packaged_task<ModifyBackupPlanNameOutcome()>>(
[this, request]()
{
return this->modifyBackupPlanName(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
DbsClient::StopBackupPlanOutcome DbsClient::stopBackupPlan(const StopBackupPlanRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return StopBackupPlanOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return StopBackupPlanOutcome(StopBackupPlanResult(outcome.result()));
else
return StopBackupPlanOutcome(outcome.error());
}
void DbsClient::stopBackupPlanAsync(const StopBackupPlanRequest& request, const StopBackupPlanAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, stopBackupPlan(request), context);
};
asyncExecute(new Runnable(fn));
}
DbsClient::StopBackupPlanOutcomeCallable DbsClient::stopBackupPlanCallable(const StopBackupPlanRequest &request) const
{
auto task = std::make_shared<std::packaged_task<StopBackupPlanOutcome()>>(
[this, request]()
{
return this->stopBackupPlan(request);
return this->createRestoreTask(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
@@ -411,108 +195,72 @@ DbsClient::DescribeBackupGatewayListOutcomeCallable DbsClient::describeBackupGat
return task->get_future();
}
DbsClient::ModifyBackupSourceEndpointOutcome DbsClient::modifyBackupSourceEndpoint(const ModifyBackupSourceEndpointRequest &request) const
DbsClient::DescribeBackupPlanListOutcome DbsClient::describeBackupPlanList(const DescribeBackupPlanListRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return ModifyBackupSourceEndpointOutcome(endpointOutcome.error());
return DescribeBackupPlanListOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return ModifyBackupSourceEndpointOutcome(ModifyBackupSourceEndpointResult(outcome.result()));
return DescribeBackupPlanListOutcome(DescribeBackupPlanListResult(outcome.result()));
else
return ModifyBackupSourceEndpointOutcome(outcome.error());
return DescribeBackupPlanListOutcome(outcome.error());
}
void DbsClient::modifyBackupSourceEndpointAsync(const ModifyBackupSourceEndpointRequest& request, const ModifyBackupSourceEndpointAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
void DbsClient::describeBackupPlanListAsync(const DescribeBackupPlanListRequest& request, const DescribeBackupPlanListAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, modifyBackupSourceEndpoint(request), context);
handler(this, request, describeBackupPlanList(request), context);
};
asyncExecute(new Runnable(fn));
}
DbsClient::ModifyBackupSourceEndpointOutcomeCallable DbsClient::modifyBackupSourceEndpointCallable(const ModifyBackupSourceEndpointRequest &request) const
DbsClient::DescribeBackupPlanListOutcomeCallable DbsClient::describeBackupPlanListCallable(const DescribeBackupPlanListRequest &request) const
{
auto task = std::make_shared<std::packaged_task<ModifyBackupSourceEndpointOutcome()>>(
auto task = std::make_shared<std::packaged_task<DescribeBackupPlanListOutcome()>>(
[this, request]()
{
return this->modifyBackupSourceEndpoint(request);
return this->describeBackupPlanList(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
DbsClient::DescribePreCheckProgressListOutcome DbsClient::describePreCheckProgressList(const DescribePreCheckProgressListRequest &request) const
DbsClient::DescribeFullBackupListOutcome DbsClient::describeFullBackupList(const DescribeFullBackupListRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return DescribePreCheckProgressListOutcome(endpointOutcome.error());
return DescribeFullBackupListOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return DescribePreCheckProgressListOutcome(DescribePreCheckProgressListResult(outcome.result()));
return DescribeFullBackupListOutcome(DescribeFullBackupListResult(outcome.result()));
else
return DescribePreCheckProgressListOutcome(outcome.error());
return DescribeFullBackupListOutcome(outcome.error());
}
void DbsClient::describePreCheckProgressListAsync(const DescribePreCheckProgressListRequest& request, const DescribePreCheckProgressListAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
void DbsClient::describeFullBackupListAsync(const DescribeFullBackupListRequest& request, const DescribeFullBackupListAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, describePreCheckProgressList(request), context);
handler(this, request, describeFullBackupList(request), context);
};
asyncExecute(new Runnable(fn));
}
DbsClient::DescribePreCheckProgressListOutcomeCallable DbsClient::describePreCheckProgressListCallable(const DescribePreCheckProgressListRequest &request) const
DbsClient::DescribeFullBackupListOutcomeCallable DbsClient::describeFullBackupListCallable(const DescribeFullBackupListRequest &request) const
{
auto task = std::make_shared<std::packaged_task<DescribePreCheckProgressListOutcome()>>(
auto task = std::make_shared<std::packaged_task<DescribeFullBackupListOutcome()>>(
[this, request]()
{
return this->describePreCheckProgressList(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
DbsClient::ModifyBackupObjectsOutcome DbsClient::modifyBackupObjects(const ModifyBackupObjectsRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return ModifyBackupObjectsOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return ModifyBackupObjectsOutcome(ModifyBackupObjectsResult(outcome.result()));
else
return ModifyBackupObjectsOutcome(outcome.error());
}
void DbsClient::modifyBackupObjectsAsync(const ModifyBackupObjectsRequest& request, const ModifyBackupObjectsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, modifyBackupObjects(request), context);
};
asyncExecute(new Runnable(fn));
}
DbsClient::ModifyBackupObjectsOutcomeCallable DbsClient::modifyBackupObjectsCallable(const ModifyBackupObjectsRequest &request) const
{
auto task = std::make_shared<std::packaged_task<ModifyBackupObjectsOutcome()>>(
[this, request]()
{
return this->modifyBackupObjects(request);
return this->describeFullBackupList(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
@@ -555,72 +303,216 @@ DbsClient::DescribeIncrementBackupListOutcomeCallable DbsClient::describeIncreme
return task->get_future();
}
DbsClient::CreateRestoreTaskOutcome DbsClient::createRestoreTask(const CreateRestoreTaskRequest &request) const
DbsClient::DescribeNodeCidrListOutcome DbsClient::describeNodeCidrList(const DescribeNodeCidrListRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return CreateRestoreTaskOutcome(endpointOutcome.error());
return DescribeNodeCidrListOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return CreateRestoreTaskOutcome(CreateRestoreTaskResult(outcome.result()));
return DescribeNodeCidrListOutcome(DescribeNodeCidrListResult(outcome.result()));
else
return CreateRestoreTaskOutcome(outcome.error());
return DescribeNodeCidrListOutcome(outcome.error());
}
void DbsClient::createRestoreTaskAsync(const CreateRestoreTaskRequest& request, const CreateRestoreTaskAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
void DbsClient::describeNodeCidrListAsync(const DescribeNodeCidrListRequest& request, const DescribeNodeCidrListAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, createRestoreTask(request), context);
handler(this, request, describeNodeCidrList(request), context);
};
asyncExecute(new Runnable(fn));
}
DbsClient::CreateRestoreTaskOutcomeCallable DbsClient::createRestoreTaskCallable(const CreateRestoreTaskRequest &request) const
DbsClient::DescribeNodeCidrListOutcomeCallable DbsClient::describeNodeCidrListCallable(const DescribeNodeCidrListRequest &request) const
{
auto task = std::make_shared<std::packaged_task<CreateRestoreTaskOutcome()>>(
auto task = std::make_shared<std::packaged_task<DescribeNodeCidrListOutcome()>>(
[this, request]()
{
return this->createRestoreTask(request);
return this->describeNodeCidrList(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
DbsClient::ConfigureBackupPlanOutcome DbsClient::configureBackupPlan(const ConfigureBackupPlanRequest &request) const
DbsClient::DescribePreCheckProgressListOutcome DbsClient::describePreCheckProgressList(const DescribePreCheckProgressListRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return ConfigureBackupPlanOutcome(endpointOutcome.error());
return DescribePreCheckProgressListOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return ConfigureBackupPlanOutcome(ConfigureBackupPlanResult(outcome.result()));
return DescribePreCheckProgressListOutcome(DescribePreCheckProgressListResult(outcome.result()));
else
return ConfigureBackupPlanOutcome(outcome.error());
return DescribePreCheckProgressListOutcome(outcome.error());
}
void DbsClient::configureBackupPlanAsync(const ConfigureBackupPlanRequest& request, const ConfigureBackupPlanAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
void DbsClient::describePreCheckProgressListAsync(const DescribePreCheckProgressListRequest& request, const DescribePreCheckProgressListAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, configureBackupPlan(request), context);
handler(this, request, describePreCheckProgressList(request), context);
};
asyncExecute(new Runnable(fn));
}
DbsClient::ConfigureBackupPlanOutcomeCallable DbsClient::configureBackupPlanCallable(const ConfigureBackupPlanRequest &request) const
DbsClient::DescribePreCheckProgressListOutcomeCallable DbsClient::describePreCheckProgressListCallable(const DescribePreCheckProgressListRequest &request) const
{
auto task = std::make_shared<std::packaged_task<ConfigureBackupPlanOutcome()>>(
auto task = std::make_shared<std::packaged_task<DescribePreCheckProgressListOutcome()>>(
[this, request]()
{
return this->configureBackupPlan(request);
return this->describePreCheckProgressList(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
DbsClient::DescribeRestoreTaskListOutcome DbsClient::describeRestoreTaskList(const DescribeRestoreTaskListRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return DescribeRestoreTaskListOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return DescribeRestoreTaskListOutcome(DescribeRestoreTaskListResult(outcome.result()));
else
return DescribeRestoreTaskListOutcome(outcome.error());
}
void DbsClient::describeRestoreTaskListAsync(const DescribeRestoreTaskListRequest& request, const DescribeRestoreTaskListAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, describeRestoreTaskList(request), context);
};
asyncExecute(new Runnable(fn));
}
DbsClient::DescribeRestoreTaskListOutcomeCallable DbsClient::describeRestoreTaskListCallable(const DescribeRestoreTaskListRequest &request) const
{
auto task = std::make_shared<std::packaged_task<DescribeRestoreTaskListOutcome()>>(
[this, request]()
{
return this->describeRestoreTaskList(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
DbsClient::ModifyBackupObjectsOutcome DbsClient::modifyBackupObjects(const ModifyBackupObjectsRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return ModifyBackupObjectsOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return ModifyBackupObjectsOutcome(ModifyBackupObjectsResult(outcome.result()));
else
return ModifyBackupObjectsOutcome(outcome.error());
}
void DbsClient::modifyBackupObjectsAsync(const ModifyBackupObjectsRequest& request, const ModifyBackupObjectsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, modifyBackupObjects(request), context);
};
asyncExecute(new Runnable(fn));
}
DbsClient::ModifyBackupObjectsOutcomeCallable DbsClient::modifyBackupObjectsCallable(const ModifyBackupObjectsRequest &request) const
{
auto task = std::make_shared<std::packaged_task<ModifyBackupObjectsOutcome()>>(
[this, request]()
{
return this->modifyBackupObjects(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
DbsClient::ModifyBackupPlanNameOutcome DbsClient::modifyBackupPlanName(const ModifyBackupPlanNameRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return ModifyBackupPlanNameOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return ModifyBackupPlanNameOutcome(ModifyBackupPlanNameResult(outcome.result()));
else
return ModifyBackupPlanNameOutcome(outcome.error());
}
void DbsClient::modifyBackupPlanNameAsync(const ModifyBackupPlanNameRequest& request, const ModifyBackupPlanNameAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, modifyBackupPlanName(request), context);
};
asyncExecute(new Runnable(fn));
}
DbsClient::ModifyBackupPlanNameOutcomeCallable DbsClient::modifyBackupPlanNameCallable(const ModifyBackupPlanNameRequest &request) const
{
auto task = std::make_shared<std::packaged_task<ModifyBackupPlanNameOutcome()>>(
[this, request]()
{
return this->modifyBackupPlanName(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
DbsClient::ModifyBackupSourceEndpointOutcome DbsClient::modifyBackupSourceEndpoint(const ModifyBackupSourceEndpointRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return ModifyBackupSourceEndpointOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return ModifyBackupSourceEndpointOutcome(ModifyBackupSourceEndpointResult(outcome.result()));
else
return ModifyBackupSourceEndpointOutcome(outcome.error());
}
void DbsClient::modifyBackupSourceEndpointAsync(const ModifyBackupSourceEndpointRequest& request, const ModifyBackupSourceEndpointAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, modifyBackupSourceEndpoint(request), context);
};
asyncExecute(new Runnable(fn));
}
DbsClient::ModifyBackupSourceEndpointOutcomeCallable DbsClient::modifyBackupSourceEndpointCallable(const ModifyBackupSourceEndpointRequest &request) const
{
auto task = std::make_shared<std::packaged_task<ModifyBackupSourceEndpointOutcome()>>(
[this, request]()
{
return this->modifyBackupSourceEndpoint(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
@@ -663,6 +555,78 @@ DbsClient::ModifyBackupStrategyOutcomeCallable DbsClient::modifyBackupStrategyCa
return task->get_future();
}
DbsClient::RenewBackupPlanOutcome DbsClient::renewBackupPlan(const RenewBackupPlanRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return RenewBackupPlanOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return RenewBackupPlanOutcome(RenewBackupPlanResult(outcome.result()));
else
return RenewBackupPlanOutcome(outcome.error());
}
void DbsClient::renewBackupPlanAsync(const RenewBackupPlanRequest& request, const RenewBackupPlanAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, renewBackupPlan(request), context);
};
asyncExecute(new Runnable(fn));
}
DbsClient::RenewBackupPlanOutcomeCallable DbsClient::renewBackupPlanCallable(const RenewBackupPlanRequest &request) const
{
auto task = std::make_shared<std::packaged_task<RenewBackupPlanOutcome()>>(
[this, request]()
{
return this->renewBackupPlan(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
DbsClient::StartBackupPlanOutcome DbsClient::startBackupPlan(const StartBackupPlanRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return StartBackupPlanOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return StartBackupPlanOutcome(StartBackupPlanResult(outcome.result()));
else
return StartBackupPlanOutcome(outcome.error());
}
void DbsClient::startBackupPlanAsync(const StartBackupPlanRequest& request, const StartBackupPlanAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, startBackupPlan(request), context);
};
asyncExecute(new Runnable(fn));
}
DbsClient::StartBackupPlanOutcomeCallable DbsClient::startBackupPlanCallable(const StartBackupPlanRequest &request) const
{
auto task = std::make_shared<std::packaged_task<StartBackupPlanOutcome()>>(
[this, request]()
{
return this->startBackupPlan(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
DbsClient::StartRestoreTaskOutcome DbsClient::startRestoreTask(const StartRestoreTaskRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -699,36 +663,72 @@ DbsClient::StartRestoreTaskOutcomeCallable DbsClient::startRestoreTaskCallable(c
return task->get_future();
}
DbsClient::DescribeNodeCidrListOutcome DbsClient::describeNodeCidrList(const DescribeNodeCidrListRequest &request) const
DbsClient::StopBackupPlanOutcome DbsClient::stopBackupPlan(const StopBackupPlanRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return DescribeNodeCidrListOutcome(endpointOutcome.error());
return StopBackupPlanOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return DescribeNodeCidrListOutcome(DescribeNodeCidrListResult(outcome.result()));
return StopBackupPlanOutcome(StopBackupPlanResult(outcome.result()));
else
return DescribeNodeCidrListOutcome(outcome.error());
return StopBackupPlanOutcome(outcome.error());
}
void DbsClient::describeNodeCidrListAsync(const DescribeNodeCidrListRequest& request, const DescribeNodeCidrListAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
void DbsClient::stopBackupPlanAsync(const StopBackupPlanRequest& request, const StopBackupPlanAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, describeNodeCidrList(request), context);
handler(this, request, stopBackupPlan(request), context);
};
asyncExecute(new Runnable(fn));
}
DbsClient::DescribeNodeCidrListOutcomeCallable DbsClient::describeNodeCidrListCallable(const DescribeNodeCidrListRequest &request) const
DbsClient::StopBackupPlanOutcomeCallable DbsClient::stopBackupPlanCallable(const StopBackupPlanRequest &request) const
{
auto task = std::make_shared<std::packaged_task<DescribeNodeCidrListOutcome()>>(
auto task = std::make_shared<std::packaged_task<StopBackupPlanOutcome()>>(
[this, request]()
{
return this->describeNodeCidrList(request);
return this->stopBackupPlan(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
DbsClient::UpgradeBackupPlanOutcome DbsClient::upgradeBackupPlan(const UpgradeBackupPlanRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return UpgradeBackupPlanOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return UpgradeBackupPlanOutcome(UpgradeBackupPlanResult(outcome.result()));
else
return UpgradeBackupPlanOutcome(outcome.error());
}
void DbsClient::upgradeBackupPlanAsync(const UpgradeBackupPlanRequest& request, const UpgradeBackupPlanAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, upgradeBackupPlan(request), context);
};
asyncExecute(new Runnable(fn));
}
DbsClient::UpgradeBackupPlanOutcomeCallable DbsClient::upgradeBackupPlanCallable(const UpgradeBackupPlanRequest &request) const
{
auto task = std::make_shared<std::packaged_task<UpgradeBackupPlanOutcome()>>(
[this, request]()
{
return this->upgradeBackupPlan(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));

165
dbs/src/model/ConfigureBackupPlanRequest.cc
View File

@@ -36,17 +36,6 @@ void ConfigureBackupPlanRequest::setSourceEndpointRegion(const std::string& sour
setCoreParameter("SourceEndpointRegion", sourceEndpointRegion);
}
int ConfigureBackupPlanRequest::getDuplicationArchivePeriod()const
{
return duplicationArchivePeriod_;
}
void ConfigureBackupPlanRequest::setDuplicationArchivePeriod(int duplicationArchivePeriod)
{
duplicationArchivePeriod_ = duplicationArchivePeriod;
setCoreParameter("DuplicationArchivePeriod", std::to_string(duplicationArchivePeriod));
}
long ConfigureBackupPlanRequest::getBackupGatewayId()const
{
return backupGatewayId_;
@@ -91,17 +80,6 @@ void ConfigureBackupPlanRequest::setClientToken(const std::string& clientToken)
setCoreParameter("ClientToken", clientToken);
}
std::string ConfigureBackupPlanRequest::getSourceEndpointPassword()const
{
return sourceEndpointPassword_;
}
void ConfigureBackupPlanRequest::setSourceEndpointPassword(const std::string& sourceEndpointPassword)
{
sourceEndpointPassword_ = sourceEndpointPassword;
setCoreParameter("SourceEndpointPassword", sourceEndpointPassword);
}
std::string ConfigureBackupPlanRequest::getBackupPlanId()const
{
return backupPlanId_;
@@ -113,6 +91,83 @@ void ConfigureBackupPlanRequest::setBackupPlanId(const std::string& backupPlanId
setCoreParameter("BackupPlanId", backupPlanId);
}
std::string ConfigureBackupPlanRequest::getSourceEndpointDatabaseName()const
{
return sourceEndpointDatabaseName_;
}
void ConfigureBackupPlanRequest::setSourceEndpointDatabaseName(const std::string& sourceEndpointDatabaseName)
{
sourceEndpointDatabaseName_ = sourceEndpointDatabaseName;
setCoreParameter("SourceEndpointDatabaseName", sourceEndpointDatabaseName);
}
int ConfigureBackupPlanRequest::getDuplicationInfrequentAccessPeriod()const
{
return duplicationInfrequentAccessPeriod_;
}
void ConfigureBackupPlanRequest::setDuplicationInfrequentAccessPeriod(int duplicationInfrequentAccessPeriod)
{
duplicationInfrequentAccessPeriod_ = duplicationInfrequentAccessPeriod;
setCoreParameter("DuplicationInfrequentAccessPeriod", std::to_string(duplicationInfrequentAccessPeriod));
}
std::string ConfigureBackupPlanRequest::getBackupStartTime()const
{
return backupStartTime_;
}
void ConfigureBackupPlanRequest::setBackupStartTime(const std::string& backupStartTime)
{
backupStartTime_ = backupStartTime;
setCoreParameter("BackupStartTime", backupStartTime);
}
std::string ConfigureBackupPlanRequest::getSourceEndpointIP()const
{
return sourceEndpointIP_;
}
void ConfigureBackupPlanRequest::setSourceEndpointIP(const std::string& sourceEndpointIP)
{
sourceEndpointIP_ = sourceEndpointIP;
setCoreParameter("SourceEndpointIP", sourceEndpointIP);
}
bool ConfigureBackupPlanRequest::getEnableBackupLog()const
{
return enableBackupLog_;
}
void ConfigureBackupPlanRequest::setEnableBackupLog(bool enableBackupLog)
{
enableBackupLog_ = enableBackupLog;
setCoreParameter("EnableBackupLog", enableBackupLog ? "true" : "false");
}
int ConfigureBackupPlanRequest::getDuplicationArchivePeriod()const
{
return duplicationArchivePeriod_;
}
void ConfigureBackupPlanRequest::setDuplicationArchivePeriod(int duplicationArchivePeriod)
{
duplicationArchivePeriod_ = duplicationArchivePeriod;
setCoreParameter("DuplicationArchivePeriod", std::to_string(duplicationArchivePeriod));
}
std::string ConfigureBackupPlanRequest::getSourceEndpointPassword()const
{
return sourceEndpointPassword_;
}
void ConfigureBackupPlanRequest::setSourceEndpointPassword(const std::string& sourceEndpointPassword)
{
sourceEndpointPassword_ = sourceEndpointPassword;
setCoreParameter("SourceEndpointPassword", sourceEndpointPassword);
}
std::string ConfigureBackupPlanRequest::getBackupObjects()const
{
return backupObjects_;
@@ -146,17 +201,6 @@ void ConfigureBackupPlanRequest::setSourceEndpointPort(int sourceEndpointPort)
setCoreParameter("SourceEndpointPort", std::to_string(sourceEndpointPort));
}
std::string ConfigureBackupPlanRequest::getSourceEndpointDatabaseName()const
{
return sourceEndpointDatabaseName_;
}
void ConfigureBackupPlanRequest::setSourceEndpointDatabaseName(const std::string& sourceEndpointDatabaseName)
{
sourceEndpointDatabaseName_ = sourceEndpointDatabaseName;
setCoreParameter("SourceEndpointDatabaseName", sourceEndpointDatabaseName);
}
int ConfigureBackupPlanRequest::getBackupRetentionPeriod()const
{
return backupRetentionPeriod_;
@@ -168,17 +212,6 @@ void ConfigureBackupPlanRequest::setBackupRetentionPeriod(int backupRetentionPer
setCoreParameter("BackupRetentionPeriod", std::to_string(backupRetentionPeriod));
}
int ConfigureBackupPlanRequest::getDuplicationInfrequentAccessPeriod()const
{
return duplicationInfrequentAccessPeriod_;
}
void ConfigureBackupPlanRequest::setDuplicationInfrequentAccessPeriod(int duplicationInfrequentAccessPeriod)
{
duplicationInfrequentAccessPeriod_ = duplicationInfrequentAccessPeriod;
setCoreParameter("DuplicationInfrequentAccessPeriod", std::to_string(duplicationInfrequentAccessPeriod));
}
std::string ConfigureBackupPlanRequest::getBackupPeriod()const
{
return backupPeriod_;
@@ -190,17 +223,6 @@ void ConfigureBackupPlanRequest::setBackupPeriod(const std::string& backupPeriod
setCoreParameter("BackupPeriod", backupPeriod);
}
std::string ConfigureBackupPlanRequest::getBackupStartTime()const
{
return backupStartTime_;
}
void ConfigureBackupPlanRequest::setBackupStartTime(const std::string& backupStartTime)
{
backupStartTime_ = backupStartTime;
setCoreParameter("BackupStartTime", backupStartTime);
}
std::string ConfigureBackupPlanRequest::getSourceEndpointInstanceType()const
{
return sourceEndpointInstanceType_;
@@ -212,17 +234,6 @@ void ConfigureBackupPlanRequest::setSourceEndpointInstanceType(const std::string
setCoreParameter("SourceEndpointInstanceType", sourceEndpointInstanceType);
}
std::string ConfigureBackupPlanRequest::getSourceEndpointIP()const
{
return sourceEndpointIP_;
}
void ConfigureBackupPlanRequest::setSourceEndpointIP(const std::string& sourceEndpointIP)
{
sourceEndpointIP_ = sourceEndpointIP;
setCoreParameter("SourceEndpointIP", sourceEndpointIP);
}
std::string ConfigureBackupPlanRequest::getBackupPlanName()const
{
return backupPlanName_;
@@ -234,17 +245,6 @@ void ConfigureBackupPlanRequest::setBackupPlanName(const std::string& backupPlan
setCoreParameter("BackupPlanName", backupPlanName);
}
std::string ConfigureBackupPlanRequest::getRegionId()const
{
return regionId_;
}
void ConfigureBackupPlanRequest::setRegionId(const std::string& regionId)
{
regionId_ = regionId;
setCoreParameter("RegionId", regionId);
}
std::string ConfigureBackupPlanRequest::getSourceEndpointOracleSID()const
{
return sourceEndpointOracleSID_;
@@ -267,14 +267,3 @@ void ConfigureBackupPlanRequest::setOSSBucketName(const std::string& oSSBucketNa
setCoreParameter("OSSBucketName", oSSBucketName);
}
bool ConfigureBackupPlanRequest::getEnableBackupLog()const
{
return enableBackupLog_;
}
void ConfigureBackupPlanRequest::setEnableBackupLog(bool enableBackupLog)
{
enableBackupLog_ = enableBackupLog;
setCoreParameter("EnableBackupLog", enableBackupLog ? "true" : "false");
}

8
dbs/src/model/ConfigureBackupPlanResult.cc
View File

@@ -35,13 +35,9 @@ ConfigureBackupPlanResult::~ConfigureBackupPlanResult()
void ConfigureBackupPlanResult::parse(const std::string &payload)
{
Json::CharReaderBuilder builder;
Json::CharReader *reader = builder.newCharReader();
Json::Value *val;
Json::Reader reader;
Json::Value value;
JSONCPP_STRING *errs;
reader->parse(payload.data(), payload.data() + payload.size(), val, errs);
value = *val;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
if(!value["Success"].isNull())
success_ = value["Success"].asString() == "true";

121
dbs/src/model/CreateBackupPlanRequest.cc
View File

@@ -36,17 +36,6 @@ void CreateBackupPlanRequest::setDatabaseType(const std::string& databaseType)
setCoreParameter("DatabaseType", databaseType);
}
std::string CreateBackupPlanRequest::getPeriod()const
{
return period_;
}
void CreateBackupPlanRequest::setPeriod(const std::string& period)
{
period_ = period;
setCoreParameter("Period", period);
}
std::string CreateBackupPlanRequest::getClientToken()const
{
return clientToken_;
@@ -58,28 +47,6 @@ void CreateBackupPlanRequest::setClientToken(const std::string& clientToken)
setCoreParameter("ClientToken", clientToken);
}
std::string CreateBackupPlanRequest::getOwnerId()const
{
return ownerId_;
}
void CreateBackupPlanRequest::setOwnerId(const std::string& ownerId)
{
ownerId_ = ownerId;
setCoreParameter("OwnerId", ownerId);
}
int CreateBackupPlanRequest::getUsedTime()const
{
return usedTime_;
}
void CreateBackupPlanRequest::setUsedTime(int usedTime)
{
usedTime_ = usedTime;
setCoreParameter("UsedTime", std::to_string(usedTime));
}
std::string CreateBackupPlanRequest::getInstanceClass()const
{
return instanceClass_;
@@ -102,17 +69,6 @@ void CreateBackupPlanRequest::setStorageType(const std::string& storageType)
setCoreParameter("StorageType", storageType);
}
std::string CreateBackupPlanRequest::getBackupMethod()const
{
return backupMethod_;
}
void CreateBackupPlanRequest::setBackupMethod(const std::string& backupMethod)
{
backupMethod_ = backupMethod;
setCoreParameter("BackupMethod", backupMethod);
}
std::string CreateBackupPlanRequest::getDatabaseRegion()const
{
return databaseRegion_;
@@ -124,28 +80,6 @@ void CreateBackupPlanRequest::setDatabaseRegion(const std::string& databaseRegio
setCoreParameter("DatabaseRegion", databaseRegion);
}
std::string CreateBackupPlanRequest::getStorageRegion()const
{
return storageRegion_;
}
void CreateBackupPlanRequest::setStorageRegion(const std::string& storageRegion)
{
storageRegion_ = storageRegion;
setCoreParameter("StorageRegion", storageRegion);
}
std::string CreateBackupPlanRequest::getRegionId()const
{
return regionId_;
}
void CreateBackupPlanRequest::setRegionId(const std::string& regionId)
{
regionId_ = regionId;
setCoreParameter("RegionId", regionId);
}
std::string CreateBackupPlanRequest::getInstanceType()const
{
return instanceType_;
@@ -157,6 +91,61 @@ void CreateBackupPlanRequest::setInstanceType(const std::string& instanceType)
setCoreParameter("InstanceType", instanceType);
}
std::string CreateBackupPlanRequest::getPeriod()const
{
return period_;
}
void CreateBackupPlanRequest::setPeriod(const std::string& period)
{
period_ = period;
setCoreParameter("Period", period);
}
std::string CreateBackupPlanRequest::getOwnerId()const
{
return ownerId_;
}
void CreateBackupPlanRequest::setOwnerId(const std::string& ownerId)
{
ownerId_ = ownerId;
setCoreParameter("OwnerId", ownerId);
}
int CreateBackupPlanRequest::getUsedTime()const
{
return usedTime_;
}
void CreateBackupPlanRequest::setUsedTime(int usedTime)
{
usedTime_ = usedTime;
setCoreParameter("UsedTime", std::to_string(usedTime));
}
std::string CreateBackupPlanRequest::getBackupMethod()const
{
return backupMethod_;
}
void CreateBackupPlanRequest::setBackupMethod(const std::string& backupMethod)
{
backupMethod_ = backupMethod;
setCoreParameter("BackupMethod", backupMethod);
}
std::string CreateBackupPlanRequest::getStorageRegion()const
{
return storageRegion_;
}
void CreateBackupPlanRequest::setStorageRegion(const std::string& storageRegion)
{
storageRegion_ = storageRegion;
setCoreParameter("StorageRegion", storageRegion);
}
std::string CreateBackupPlanRequest::getRegion()const
{
return region_;

8
dbs/src/model/CreateBackupPlanResult.cc
View File

@@ -35,13 +35,9 @@ CreateBackupPlanResult::~CreateBackupPlanResult()
void CreateBackupPlanResult::parse(const std::string &payload)
{
Json::CharReaderBuilder builder;
Json::CharReader *reader = builder.newCharReader();
Json::Value *val;
Json::Reader reader;
Json::Value value;
JSONCPP_STRING *errs;
reader->parse(payload.data(), payload.data() + payload.size(), val, errs);
value = *val;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
if(!value["Success"].isNull())
success_ = value["Success"].asString() == "true";

209
dbs/src/model/CreateRestoreTaskRequest.cc
View File

@@ -36,28 +36,6 @@ void CreateRestoreTaskRequest::setBackupGatewayId(long backupGatewayId)
setCoreParameter("BackupGatewayId", std::to_string(backupGatewayId));
}
std::string CreateRestoreTaskRequest::getDestinationEndpointOracleSID()const
{
return destinationEndpointOracleSID_;
}
void CreateRestoreTaskRequest::setDestinationEndpointOracleSID(const std::string& destinationEndpointOracleSID)
{
destinationEndpointOracleSID_ = destinationEndpointOracleSID;
setCoreParameter("DestinationEndpointOracleSID", destinationEndpointOracleSID);
}
long CreateRestoreTaskRequest::getRestoreTime()const
{
return restoreTime_;
}
void CreateRestoreTaskRequest::setRestoreTime(long restoreTime)
{
restoreTime_ = restoreTime;
setCoreParameter("RestoreTime", std::to_string(restoreTime));
}
std::string CreateRestoreTaskRequest::getDestinationEndpointInstanceType()const
{
return destinationEndpointInstanceType_;
@@ -80,28 +58,6 @@ void CreateRestoreTaskRequest::setClientToken(const std::string& clientToken)
setCoreParameter("ClientToken", clientToken);
}
std::string CreateRestoreTaskRequest::getDestinationEndpointInstanceID()const
{
return destinationEndpointInstanceID_;
}
void CreateRestoreTaskRequest::setDestinationEndpointInstanceID(const std::string& destinationEndpointInstanceID)
{
destinationEndpointInstanceID_ = destinationEndpointInstanceID;
setCoreParameter("DestinationEndpointInstanceID", destinationEndpointInstanceID);
}
int CreateRestoreTaskRequest::getDestinationEndpointPort()const
{
return destinationEndpointPort_;
}
void CreateRestoreTaskRequest::setDestinationEndpointPort(int destinationEndpointPort)
{
destinationEndpointPort_ = destinationEndpointPort;
setCoreParameter("DestinationEndpointPort", std::to_string(destinationEndpointPort));
}
std::string CreateRestoreTaskRequest::getBackupPlanId()const
{
return backupPlanId_;
@@ -113,28 +69,6 @@ void CreateRestoreTaskRequest::setBackupPlanId(const std::string& backupPlanId)
setCoreParameter("BackupPlanId", backupPlanId);
}
std::string CreateRestoreTaskRequest::getBackupSetId()const
{
return backupSetId_;
}
void CreateRestoreTaskRequest::setBackupSetId(const std::string& backupSetId)
{
backupSetId_ = backupSetId;
setCoreParameter("BackupSetId", backupSetId);
}
std::string CreateRestoreTaskRequest::getOwnerId()const
{
return ownerId_;
}
void CreateRestoreTaskRequest::setOwnerId(const std::string& ownerId)
{
ownerId_ = ownerId;
setCoreParameter("OwnerId", ownerId);
}
std::string CreateRestoreTaskRequest::getDestinationEndpointRegion()const
{
return destinationEndpointRegion_;
@@ -146,50 +80,6 @@ void CreateRestoreTaskRequest::setDestinationEndpointRegion(const std::string& d
setCoreParameter("DestinationEndpointRegion", destinationEndpointRegion);
}
std::string CreateRestoreTaskRequest::getRestoreDir()const
{
return restoreDir_;
}
void CreateRestoreTaskRequest::setRestoreDir(const std::string& restoreDir)
{
restoreDir_ = restoreDir;
setCoreParameter("RestoreDir", restoreDir);
}
std::string CreateRestoreTaskRequest::getDestinationEndpointIP()const
{
return destinationEndpointIP_;
}
void CreateRestoreTaskRequest::setDestinationEndpointIP(const std::string& destinationEndpointIP)
{
destinationEndpointIP_ = destinationEndpointIP;
setCoreParameter("DestinationEndpointIP", destinationEndpointIP);
}
std::string CreateRestoreTaskRequest::getRegionId()const
{
return regionId_;
}
void CreateRestoreTaskRequest::setRegionId(const std::string& regionId)
{
regionId_ = regionId;
setCoreParameter("RegionId", regionId);
}
std::string CreateRestoreTaskRequest::getDestinationEndpointDatabaseName()const
{
return destinationEndpointDatabaseName_;
}
void CreateRestoreTaskRequest::setDestinationEndpointDatabaseName(const std::string& destinationEndpointDatabaseName)
{
destinationEndpointDatabaseName_ = destinationEndpointDatabaseName;
setCoreParameter("DestinationEndpointDatabaseName", destinationEndpointDatabaseName);
}
std::string CreateRestoreTaskRequest::getDestinationEndpointUserName()const
{
return destinationEndpointUserName_;
@@ -223,6 +113,105 @@ void CreateRestoreTaskRequest::setRestoreTaskName(const std::string& restoreTask
setCoreParameter("RestoreTaskName", restoreTaskName);
}
std::string CreateRestoreTaskRequest::getDestinationEndpointOracleSID()const
{
return destinationEndpointOracleSID_;
}
void CreateRestoreTaskRequest::setDestinationEndpointOracleSID(const std::string& destinationEndpointOracleSID)
{
destinationEndpointOracleSID_ = destinationEndpointOracleSID;
setCoreParameter("DestinationEndpointOracleSID", destinationEndpointOracleSID);
}
long CreateRestoreTaskRequest::getRestoreTime()const
{
return restoreTime_;
}
void CreateRestoreTaskRequest::setRestoreTime(long restoreTime)
{
restoreTime_ = restoreTime;
setCoreParameter("RestoreTime", std::to_string(restoreTime));
}
std::string CreateRestoreTaskRequest::getDestinationEndpointInstanceID()const
{
return destinationEndpointInstanceID_;
}
void CreateRestoreTaskRequest::setDestinationEndpointInstanceID(const std::string& destinationEndpointInstanceID)
{
destinationEndpointInstanceID_ = destinationEndpointInstanceID;
setCoreParameter("DestinationEndpointInstanceID", destinationEndpointInstanceID);
}
int CreateRestoreTaskRequest::getDestinationEndpointPort()const
{
return destinationEndpointPort_;
}
void CreateRestoreTaskRequest::setDestinationEndpointPort(int destinationEndpointPort)
{
destinationEndpointPort_ = destinationEndpointPort;
setCoreParameter("DestinationEndpointPort", std::to_string(destinationEndpointPort));
}
std::string CreateRestoreTaskRequest::getBackupSetId()const
{
return backupSetId_;
}
void CreateRestoreTaskRequest::setBackupSetId(const std::string& backupSetId)
{
backupSetId_ = backupSetId;
setCoreParameter("BackupSetId", backupSetId);
}
std::string CreateRestoreTaskRequest::getOwnerId()const
{
return ownerId_;
}
void CreateRestoreTaskRequest::setOwnerId(const std::string& ownerId)
{
ownerId_ = ownerId;
setCoreParameter("OwnerId", ownerId);
}
std::string CreateRestoreTaskRequest::getRestoreDir()const
{
return restoreDir_;
}
void CreateRestoreTaskRequest::setRestoreDir(const std::string& restoreDir)
{
restoreDir_ = restoreDir;
setCoreParameter("RestoreDir", restoreDir);
}
std::string CreateRestoreTaskRequest::getDestinationEndpointIP()const
{
return destinationEndpointIP_;
}
void CreateRestoreTaskRequest::setDestinationEndpointIP(const std::string& destinationEndpointIP)
{
destinationEndpointIP_ = destinationEndpointIP;
setCoreParameter("DestinationEndpointIP", destinationEndpointIP);
}
std::string CreateRestoreTaskRequest::getDestinationEndpointDatabaseName()const
{
return destinationEndpointDatabaseName_;
}
void CreateRestoreTaskRequest::setDestinationEndpointDatabaseName(const std::string& destinationEndpointDatabaseName)
{
destinationEndpointDatabaseName_ = destinationEndpointDatabaseName;
setCoreParameter("DestinationEndpointDatabaseName", destinationEndpointDatabaseName);
}
std::string CreateRestoreTaskRequest::getDuplicateConflict()const
{
return duplicateConflict_;

8
dbs/src/model/CreateRestoreTaskResult.cc
View File

@@ -35,13 +35,9 @@ CreateRestoreTaskResult::~CreateRestoreTaskResult()
void CreateRestoreTaskResult::parse(const std::string &payload)
{
Json::CharReaderBuilder builder;
Json::CharReader *reader = builder.newCharReader();
Json::Value *val;
Json::Reader reader;
Json::Value value;
JSONCPP_STRING *errs;
reader->parse(payload.data(), payload.data() + payload.size(), val, errs);
value = *val;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
if(!value["Success"].isNull())
success_ = value["Success"].asString() == "true";

55
dbs/src/model/DescribeBackupGatewayListRequest.cc
View File

@@ -36,17 +36,6 @@ void DescribeBackupGatewayListRequest::setIdentifier(const std::string& identifi
setCoreParameter("Identifier", identifier);
}
std::string DescribeBackupGatewayListRequest::getRegionId()const
{
return regionId_;
}
void DescribeBackupGatewayListRequest::setRegionId(const std::string& regionId)
{
regionId_ = regionId;
setCoreParameter("RegionId", regionId);
}
std::string DescribeBackupGatewayListRequest::getClientToken()const
{
return clientToken_;
@@ -58,28 +47,6 @@ void DescribeBackupGatewayListRequest::setClientToken(const std::string& clientT
setCoreParameter("ClientToken", clientToken);
}
int DescribeBackupGatewayListRequest::getPageSize()const
{
return pageSize_;
}
void DescribeBackupGatewayListRequest::setPageSize(int pageSize)
{
pageSize_ = pageSize;
setCoreParameter("PageSize", std::to_string(pageSize));
}
std::string DescribeBackupGatewayListRequest::getRegion()const
{
return region_;
}
void DescribeBackupGatewayListRequest::setRegion(const std::string& region)
{
region_ = region;
setCoreParameter("Region", region);
}
int DescribeBackupGatewayListRequest::getPageNum()const
{
return pageNum_;
@@ -102,3 +69,25 @@ void DescribeBackupGatewayListRequest::setOwnerId(const std::string& ownerId)
setCoreParameter("OwnerId", ownerId);
}
int DescribeBackupGatewayListRequest::getPageSize()const
{
return pageSize_;
}
void DescribeBackupGatewayListRequest::setPageSize(int pageSize)
{
pageSize_ = pageSize;
setCoreParameter("PageSize", std::to_string(pageSize));
}
std::string DescribeBackupGatewayListRequest::getRegion()const
{
return region_;
}
void DescribeBackupGatewayListRequest::setRegion(const std::string& region)
{
region_ = region;
setCoreParameter("Region", region);
}

8
dbs/src/model/DescribeBackupGatewayListResult.cc
View File

@@ -35,13 +35,9 @@ DescribeBackupGatewayListResult::~DescribeBackupGatewayListResult()
void DescribeBackupGatewayListResult::parse(const std::string &payload)
{
Json::CharReaderBuilder builder;
Json::CharReader *reader = builder.newCharReader();
Json::Value *val;
Json::Reader reader;
Json::Value value;
JSONCPP_STRING *errs;
reader->parse(payload.data(), payload.data() + payload.size(), val, errs);
value = *val;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
auto allItems = value["Items"]["BackupGateway"];
for (auto value : allItems)

55
dbs/src/model/DescribeBackupPlanListRequest.cc
View File

@@ -25,17 +25,6 @@ DescribeBackupPlanListRequest::DescribeBackupPlanListRequest() :
DescribeBackupPlanListRequest::~DescribeBackupPlanListRequest()
{}
std::string DescribeBackupPlanListRequest::getRegionId()const
{
return regionId_;
}
void DescribeBackupPlanListRequest::setRegionId(const std::string& regionId)
{
regionId_ = regionId;
setCoreParameter("RegionId", regionId);
}
std::string DescribeBackupPlanListRequest::getClientToken()const
{
return clientToken_;
@@ -47,17 +36,6 @@ void DescribeBackupPlanListRequest::setClientToken(const std::string& clientToke
setCoreParameter("ClientToken", clientToken);
}
int DescribeBackupPlanListRequest::getPageSize()const
{
return pageSize_;
}
void DescribeBackupPlanListRequest::setPageSize(int pageSize)
{
pageSize_ = pageSize;
setCoreParameter("PageSize", std::to_string(pageSize));
}
std::string DescribeBackupPlanListRequest::getBackupPlanId()const
{
return backupPlanId_;
@@ -69,17 +47,6 @@ void DescribeBackupPlanListRequest::setBackupPlanId(const std::string& backupPla
setCoreParameter("BackupPlanId", backupPlanId);
}
std::string DescribeBackupPlanListRequest::getRegion()const
{
return region_;
}
void DescribeBackupPlanListRequest::setRegion(const std::string& region)
{
region_ = region;
setCoreParameter("Region", region);
}
int DescribeBackupPlanListRequest::getPageNum()const
{
return pageNum_;
@@ -102,3 +69,25 @@ void DescribeBackupPlanListRequest::setOwnerId(const std::string& ownerId)
setCoreParameter("OwnerId", ownerId);
}
int DescribeBackupPlanListRequest::getPageSize()const
{
return pageSize_;
}
void DescribeBackupPlanListRequest::setPageSize(int pageSize)
{
pageSize_ = pageSize;
setCoreParameter("PageSize", std::to_string(pageSize));
}
std::string DescribeBackupPlanListRequest::getRegion()const
{
return region_;
}
void DescribeBackupPlanListRequest::setRegion(const std::string& region)
{
region_ = region;
setCoreParameter("Region", region);
}

8
dbs/src/model/DescribeBackupPlanListResult.cc
View File

@@ -35,13 +35,9 @@ DescribeBackupPlanListResult::~DescribeBackupPlanListResult()
void DescribeBackupPlanListResult::parse(const std::string &payload)
{
Json::CharReaderBuilder builder;
Json::CharReader *reader = builder.newCharReader();
Json::Value *val;
Json::Reader reader;
Json::Value value;
JSONCPP_STRING *errs;
reader->parse(payload.data(), payload.data() + payload.size(), val, errs);
value = *val;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
auto allItems = value["Items"]["BackupPlanDetail"];
for (auto value : allItems)

33
dbs/src/model/DescribeFullBackupListRequest.cc
View File

@@ -25,17 +25,6 @@ DescribeFullBackupListRequest::DescribeFullBackupListRequest() :
DescribeFullBackupListRequest::~DescribeFullBackupListRequest()
{}
std::string DescribeFullBackupListRequest::getRegionId()const
{
return regionId_;
}
void DescribeFullBackupListRequest::setRegionId(const std::string& regionId)
{
regionId_ = regionId;
setCoreParameter("RegionId", regionId);
}
std::string DescribeFullBackupListRequest::getClientToken()const
{
return clientToken_;
@@ -47,17 +36,6 @@ void DescribeFullBackupListRequest::setClientToken(const std::string& clientToke
setCoreParameter("ClientToken", clientToken);
}
int DescribeFullBackupListRequest::getPageSize()const
{
return pageSize_;
}
void DescribeFullBackupListRequest::setPageSize(int pageSize)
{
pageSize_ = pageSize;
setCoreParameter("PageSize", std::to_string(pageSize));
}
std::string DescribeFullBackupListRequest::getBackupPlanId()const
{
return backupPlanId_;
@@ -91,3 +69,14 @@ void DescribeFullBackupListRequest::setOwnerId(const std::string& ownerId)
setCoreParameter("OwnerId", ownerId);
}
int DescribeFullBackupListRequest::getPageSize()const
{
return pageSize_;
}
void DescribeFullBackupListRequest::setPageSize(int pageSize)
{
pageSize_ = pageSize;
setCoreParameter("PageSize", std::to_string(pageSize));
}

8
dbs/src/model/DescribeFullBackupListResult.cc
View File

@@ -35,13 +35,9 @@ DescribeFullBackupListResult::~DescribeFullBackupListResult()
void DescribeFullBackupListResult::parse(const std::string &payload)
{
Json::CharReaderBuilder builder;
Json::CharReader *reader = builder.newCharReader();
Json::Value *val;
Json::Reader reader;
Json::Value value;
JSONCPP_STRING *errs;
reader->parse(payload.data(), payload.data() + payload.size(), val, errs);
value = *val;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
auto allItems = value["Items"]["FullBackupFile"];
for (auto value : allItems)

33
dbs/src/model/DescribeIncrementBackupListRequest.cc
View File

@@ -25,17 +25,6 @@ DescribeIncrementBackupListRequest::DescribeIncrementBackupListRequest() :
DescribeIncrementBackupListRequest::~DescribeIncrementBackupListRequest()
{}
std::string DescribeIncrementBackupListRequest::getRegionId()const
{
return regionId_;
}
void DescribeIncrementBackupListRequest::setRegionId(const std::string& regionId)
{
regionId_ = regionId;
setCoreParameter("RegionId", regionId);
}
std::string DescribeIncrementBackupListRequest::getClientToken()const
{
return clientToken_;
@@ -47,17 +36,6 @@ void DescribeIncrementBackupListRequest::setClientToken(const std::string& clien
setCoreParameter("ClientToken", clientToken);
}
int DescribeIncrementBackupListRequest::getPageSize()const
{
return pageSize_;
}
void DescribeIncrementBackupListRequest::setPageSize(int pageSize)
{
pageSize_ = pageSize;
setCoreParameter("PageSize", std::to_string(pageSize));
}
std::string DescribeIncrementBackupListRequest::getBackupPlanId()const
{
return backupPlanId_;
@@ -91,3 +69,14 @@ void DescribeIncrementBackupListRequest::setOwnerId(const std::string& ownerId)
setCoreParameter("OwnerId", ownerId);
}
int DescribeIncrementBackupListRequest::getPageSize()const
{
return pageSize_;
}
void DescribeIncrementBackupListRequest::setPageSize(int pageSize)
{
pageSize_ = pageSize;
setCoreParameter("PageSize", std::to_string(pageSize));
}

8
dbs/src/model/DescribeIncrementBackupListResult.cc
View File

@@ -35,13 +35,9 @@ DescribeIncrementBackupListResult::~DescribeIncrementBackupListResult()
void DescribeIncrementBackupListResult::parse(const std::string &payload)
{
Json::CharReaderBuilder builder;
Json::CharReader *reader = builder.newCharReader();
Json::Value *val;
Json::Reader reader;
Json::Value value;
JSONCPP_STRING *errs;
reader->parse(payload.data(), payload.data() + payload.size(), val, errs);
value = *val;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
auto allItems = value["Items"]["IncrementBackupFile"];
for (auto value : allItems)

33
dbs/src/model/DescribeNodeCidrListRequest.cc
View File

@@ -25,17 +25,6 @@ DescribeNodeCidrListRequest::DescribeNodeCidrListRequest() :
DescribeNodeCidrListRequest::~DescribeNodeCidrListRequest()
{}
std::string DescribeNodeCidrListRequest::getRegionId()const
{
return regionId_;
}
void DescribeNodeCidrListRequest::setRegionId(const std::string& regionId)
{
regionId_ = regionId;
setCoreParameter("RegionId", regionId);
}
std::string DescribeNodeCidrListRequest::getClientToken()const
{
return clientToken_;
@@ -47,17 +36,6 @@ void DescribeNodeCidrListRequest::setClientToken(const std::string& clientToken)
setCoreParameter("ClientToken", clientToken);
}
std::string DescribeNodeCidrListRequest::getRegion()const
{
return region_;
}
void DescribeNodeCidrListRequest::setRegion(const std::string& region)
{
region_ = region;
setCoreParameter("Region", region);
}
std::string DescribeNodeCidrListRequest::getOwnerId()const
{
return ownerId_;
@@ -69,3 +47,14 @@ void DescribeNodeCidrListRequest::setOwnerId(const std::string& ownerId)
setCoreParameter("OwnerId", ownerId);
}
std::string DescribeNodeCidrListRequest::getRegion()const
{
return region_;
}
void DescribeNodeCidrListRequest::setRegion(const std::string& region)
{
region_ = region;
setCoreParameter("Region", region);
}

8
dbs/src/model/DescribeNodeCidrListResult.cc
View File

@@ -35,13 +35,9 @@ DescribeNodeCidrListResult::~DescribeNodeCidrListResult()
void DescribeNodeCidrListResult::parse(const std::string &payload)
{
Json::CharReaderBuilder builder;
Json::CharReader *reader = builder.newCharReader();
Json::Value *val;
Json::Reader reader;
Json::Value value;
JSONCPP_STRING *errs;
reader->parse(payload.data(), payload.data() + payload.size(), val, errs);
value = *val;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
auto allInternetIPs = value["InternetIPs"]["InternetIP"];
for (const auto &item : allInternetIPs)

33
dbs/src/model/DescribePreCheckProgressListRequest.cc
View File

@@ -25,17 +25,6 @@ DescribePreCheckProgressListRequest::DescribePreCheckProgressListRequest() :
DescribePreCheckProgressListRequest::~DescribePreCheckProgressListRequest()
{}
std::string DescribePreCheckProgressListRequest::getRegionId()const
{
return regionId_;
}
void DescribePreCheckProgressListRequest::setRegionId(const std::string& regionId)
{
regionId_ = regionId;
setCoreParameter("RegionId", regionId);
}
std::string DescribePreCheckProgressListRequest::getClientToken()const
{
return clientToken_;
@@ -47,17 +36,6 @@ void DescribePreCheckProgressListRequest::setClientToken(const std::string& clie
setCoreParameter("ClientToken", clientToken);
}
std::string DescribePreCheckProgressListRequest::getRestoreTaskId()const
{
return restoreTaskId_;
}
void DescribePreCheckProgressListRequest::setRestoreTaskId(const std::string& restoreTaskId)
{
restoreTaskId_ = restoreTaskId;
setCoreParameter("RestoreTaskId", restoreTaskId);
}
std::string DescribePreCheckProgressListRequest::getBackupPlanId()const
{
return backupPlanId_;
@@ -80,3 +58,14 @@ void DescribePreCheckProgressListRequest::setOwnerId(const std::string& ownerId)
setCoreParameter("OwnerId", ownerId);
}
std::string DescribePreCheckProgressListRequest::getRestoreTaskId()const
{
return restoreTaskId_;
}
void DescribePreCheckProgressListRequest::setRestoreTaskId(const std::string& restoreTaskId)
{
restoreTaskId_ = restoreTaskId;
setCoreParameter("RestoreTaskId", restoreTaskId);
}

8
dbs/src/model/DescribePreCheckProgressListResult.cc
View File

@@ -35,13 +35,9 @@ DescribePreCheckProgressListResult::~DescribePreCheckProgressListResult()
void DescribePreCheckProgressListResult::parse(const std::string &payload)
{
Json::CharReaderBuilder builder;
Json::CharReader *reader = builder.newCharReader();
Json::Value *val;
Json::Reader reader;
Json::Value value;
JSONCPP_STRING *errs;
reader->parse(payload.data(), payload.data() + payload.size(), val, errs);
value = *val;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
auto allItems = value["Items"]["PreCheckProgressDetail"];
for (auto value : allItems)

55
dbs/src/model/DescribeRestoreTaskListRequest.cc
View File

@@ -25,17 +25,6 @@ DescribeRestoreTaskListRequest::DescribeRestoreTaskListRequest() :
DescribeRestoreTaskListRequest::~DescribeRestoreTaskListRequest()
{}
std::string DescribeRestoreTaskListRequest::getRegionId()const
{
return regionId_;
}
void DescribeRestoreTaskListRequest::setRegionId(const std::string& regionId)
{
regionId_ = regionId;
setCoreParameter("RegionId", regionId);
}
std::string DescribeRestoreTaskListRequest::getClientToken()const
{
return clientToken_;
@@ -47,28 +36,6 @@ void DescribeRestoreTaskListRequest::setClientToken(const std::string& clientTok
setCoreParameter("ClientToken", clientToken);
}
std::string DescribeRestoreTaskListRequest::getRestoreTaskId()const
{
return restoreTaskId_;
}
void DescribeRestoreTaskListRequest::setRestoreTaskId(const std::string& restoreTaskId)
{
restoreTaskId_ = restoreTaskId;
setCoreParameter("RestoreTaskId", restoreTaskId);
}
int DescribeRestoreTaskListRequest::getPageSize()const
{
return pageSize_;
}
void DescribeRestoreTaskListRequest::setPageSize(int pageSize)
{
pageSize_ = pageSize;
setCoreParameter("PageSize", std::to_string(pageSize));
}
std::string DescribeRestoreTaskListRequest::getBackupPlanId()const
{
return backupPlanId_;
@@ -102,3 +69,25 @@ void DescribeRestoreTaskListRequest::setOwnerId(const std::string& ownerId)
setCoreParameter("OwnerId", ownerId);
}
std::string DescribeRestoreTaskListRequest::getRestoreTaskId()const
{
return restoreTaskId_;
}
void DescribeRestoreTaskListRequest::setRestoreTaskId(const std::string& restoreTaskId)
{
restoreTaskId_ = restoreTaskId;
setCoreParameter("RestoreTaskId", restoreTaskId);
}
int DescribeRestoreTaskListRequest::getPageSize()const
{
return pageSize_;
}
void DescribeRestoreTaskListRequest::setPageSize(int pageSize)
{
pageSize_ = pageSize;
setCoreParameter("PageSize", std::to_string(pageSize));
}

8
dbs/src/model/DescribeRestoreTaskListResult.cc
View File

@@ -35,13 +35,9 @@ DescribeRestoreTaskListResult::~DescribeRestoreTaskListResult()
void DescribeRestoreTaskListResult::parse(const std::string &payload)
{
Json::CharReaderBuilder builder;
Json::CharReader *reader = builder.newCharReader();
Json::Value *val;
Json::Reader reader;
Json::Value value;
JSONCPP_STRING *errs;
reader->parse(payload.data(), payload.data() + payload.size(), val, errs);
value = *val;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
auto allItems = value["Items"]["RestoreTaskDetail"];
for (auto value : allItems)

11
dbs/src/model/ModifyBackupObjectsRequest.cc
View File

@@ -25,17 +25,6 @@ ModifyBackupObjectsRequest::ModifyBackupObjectsRequest() :
ModifyBackupObjectsRequest::~ModifyBackupObjectsRequest()
{}
std::string ModifyBackupObjectsRequest::getRegionId()const
{
return regionId_;
}
void ModifyBackupObjectsRequest::setRegionId(const std::string& regionId)
{
regionId_ = regionId;
setCoreParameter("RegionId", regionId);
}
std::string ModifyBackupObjectsRequest::getClientToken()const
{
return clientToken_;

8
dbs/src/model/ModifyBackupObjectsResult.cc
View File

@@ -35,13 +35,9 @@ ModifyBackupObjectsResult::~ModifyBackupObjectsResult()
void ModifyBackupObjectsResult::parse(const std::string &payload)
{
Json::CharReaderBuilder builder;
Json::CharReader *reader = builder.newCharReader();
Json::Value *val;
Json::Reader reader;
Json::Value value;
JSONCPP_STRING *errs;
reader->parse(payload.data(), payload.data() + payload.size(), val, errs);
value = *val;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
if(!value["Success"].isNull())
success_ = value["Success"].asString() == "true";

33
dbs/src/model/ModifyBackupPlanNameRequest.cc
View File

@@ -25,28 +25,6 @@ ModifyBackupPlanNameRequest::ModifyBackupPlanNameRequest() :
ModifyBackupPlanNameRequest::~ModifyBackupPlanNameRequest()
{}
std::string ModifyBackupPlanNameRequest::getBackupPlanName()const
{
return backupPlanName_;
}
void ModifyBackupPlanNameRequest::setBackupPlanName(const std::string& backupPlanName)
{
backupPlanName_ = backupPlanName;
setCoreParameter("BackupPlanName", backupPlanName);
}
std::string ModifyBackupPlanNameRequest::getRegionId()const
{
return regionId_;
}
void ModifyBackupPlanNameRequest::setRegionId(const std::string& regionId)
{
regionId_ = regionId;
setCoreParameter("RegionId", regionId);
}
std::string ModifyBackupPlanNameRequest::getClientToken()const
{
return clientToken_;
@@ -80,3 +58,14 @@ void ModifyBackupPlanNameRequest::setOwnerId(const std::string& ownerId)
setCoreParameter("OwnerId", ownerId);
}
std::string ModifyBackupPlanNameRequest::getBackupPlanName()const
{
return backupPlanName_;
}
void ModifyBackupPlanNameRequest::setBackupPlanName(const std::string& backupPlanName)
{
backupPlanName_ = backupPlanName;
setCoreParameter("BackupPlanName", backupPlanName);
}

8
dbs/src/model/ModifyBackupPlanNameResult.cc
View File

@@ -35,13 +35,9 @@ ModifyBackupPlanNameResult::~ModifyBackupPlanNameResult()
void ModifyBackupPlanNameResult::parse(const std::string &payload)
{
Json::CharReaderBuilder builder;
Json::CharReader *reader = builder.newCharReader();
Json::Value *val;
Json::Reader reader;
Json::Value value;
JSONCPP_STRING *errs;
reader->parse(payload.data(), payload.data() + payload.size(), val, errs);
value = *val;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
if(!value["Success"].isNull())
success_ = value["Success"].asString() == "true";

77
dbs/src/model/ModifyBackupSourceEndpointRequest.cc
View File

@@ -80,17 +80,6 @@ void ModifyBackupSourceEndpointRequest::setClientToken(const std::string& client
setCoreParameter("ClientToken", clientToken);
}
std::string ModifyBackupSourceEndpointRequest::getSourceEndpointPassword()const
{
return sourceEndpointPassword_;
}
void ModifyBackupSourceEndpointRequest::setSourceEndpointPassword(const std::string& sourceEndpointPassword)
{
sourceEndpointPassword_ = sourceEndpointPassword;
setCoreParameter("SourceEndpointPassword", sourceEndpointPassword);
}
std::string ModifyBackupSourceEndpointRequest::getBackupPlanId()const
{
return backupPlanId_;
@@ -102,6 +91,39 @@ void ModifyBackupSourceEndpointRequest::setBackupPlanId(const std::string& backu
setCoreParameter("BackupPlanId", backupPlanId);
}
std::string ModifyBackupSourceEndpointRequest::getSourceEndpointDatabaseName()const
{
return sourceEndpointDatabaseName_;
}
void ModifyBackupSourceEndpointRequest::setSourceEndpointDatabaseName(const std::string& sourceEndpointDatabaseName)
{
sourceEndpointDatabaseName_ = sourceEndpointDatabaseName;
setCoreParameter("SourceEndpointDatabaseName", sourceEndpointDatabaseName);
}
std::string ModifyBackupSourceEndpointRequest::getSourceEndpointIP()const
{
return sourceEndpointIP_;
}
void ModifyBackupSourceEndpointRequest::setSourceEndpointIP(const std::string& sourceEndpointIP)
{
sourceEndpointIP_ = sourceEndpointIP;
setCoreParameter("SourceEndpointIP", sourceEndpointIP);
}
std::string ModifyBackupSourceEndpointRequest::getSourceEndpointPassword()const
{
return sourceEndpointPassword_;
}
void ModifyBackupSourceEndpointRequest::setSourceEndpointPassword(const std::string& sourceEndpointPassword)
{
sourceEndpointPassword_ = sourceEndpointPassword;
setCoreParameter("SourceEndpointPassword", sourceEndpointPassword);
}
std::string ModifyBackupSourceEndpointRequest::getBackupObjects()const
{
return backupObjects_;
@@ -135,17 +157,6 @@ void ModifyBackupSourceEndpointRequest::setSourceEndpointPort(int sourceEndpoint
setCoreParameter("SourceEndpointPort", std::to_string(sourceEndpointPort));
}
std::string ModifyBackupSourceEndpointRequest::getSourceEndpointDatabaseName()const
{
return sourceEndpointDatabaseName_;
}
void ModifyBackupSourceEndpointRequest::setSourceEndpointDatabaseName(const std::string& sourceEndpointDatabaseName)
{
sourceEndpointDatabaseName_ = sourceEndpointDatabaseName;
setCoreParameter("SourceEndpointDatabaseName", sourceEndpointDatabaseName);
}
std::string ModifyBackupSourceEndpointRequest::getSourceEndpointInstanceType()const
{
return sourceEndpointInstanceType_;
@@ -157,28 +168,6 @@ void ModifyBackupSourceEndpointRequest::setSourceEndpointInstanceType(const std:
setCoreParameter("SourceEndpointInstanceType", sourceEndpointInstanceType);
}
std::string ModifyBackupSourceEndpointRequest::getSourceEndpointIP()const
{
return sourceEndpointIP_;
}
void ModifyBackupSourceEndpointRequest::setSourceEndpointIP(const std::string& sourceEndpointIP)
{
sourceEndpointIP_ = sourceEndpointIP;
setCoreParameter("SourceEndpointIP", sourceEndpointIP);
}
std::string ModifyBackupSourceEndpointRequest::getRegionId()const
{
return regionId_;
}
void ModifyBackupSourceEndpointRequest::setRegionId(const std::string& regionId)
{
regionId_ = regionId;
setCoreParameter("RegionId", regionId);
}
std::string ModifyBackupSourceEndpointRequest::getSourceEndpointOracleSID()const
{
return sourceEndpointOracleSID_;

8
dbs/src/model/ModifyBackupSourceEndpointResult.cc
View File

@@ -35,13 +35,9 @@ ModifyBackupSourceEndpointResult::~ModifyBackupSourceEndpointResult()
void ModifyBackupSourceEndpointResult::parse(const std::string &payload)
{
Json::CharReaderBuilder builder;
Json::CharReader *reader = builder.newCharReader();
Json::Value *val;
Json::Reader reader;
Json::Value value;
JSONCPP_STRING *errs;
reader->parse(payload.data(), payload.data() + payload.size(), val, errs);
value = *val;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
if(!value["Success"].isNull())
success_ = value["Success"].asString() == "true";

55
dbs/src/model/ModifyBackupStrategyRequest.cc
View File

@@ -25,39 +25,6 @@ ModifyBackupStrategyRequest::ModifyBackupStrategyRequest() :
ModifyBackupStrategyRequest::~ModifyBackupStrategyRequest()
{}
std::string ModifyBackupStrategyRequest::getBackupPeriod()const
{
return backupPeriod_;
}
void ModifyBackupStrategyRequest::setBackupPeriod(const std::string& backupPeriod)
{
backupPeriod_ = backupPeriod;
setCoreParameter("BackupPeriod", backupPeriod);
}
std::string ModifyBackupStrategyRequest::getBackupStartTime()const
{
return backupStartTime_;
}
void ModifyBackupStrategyRequest::setBackupStartTime(const std::string& backupStartTime)
{
backupStartTime_ = backupStartTime;
setCoreParameter("BackupStartTime", backupStartTime);
}
std::string ModifyBackupStrategyRequest::getRegionId()const
{
return regionId_;
}
void ModifyBackupStrategyRequest::setRegionId(const std::string& regionId)
{
regionId_ = regionId;
setCoreParameter("RegionId", regionId);
}
std::string ModifyBackupStrategyRequest::getClientToken()const
{
return clientToken_;
@@ -91,3 +58,25 @@ void ModifyBackupStrategyRequest::setOwnerId(const std::string& ownerId)
setCoreParameter("OwnerId", ownerId);
}
std::string ModifyBackupStrategyRequest::getBackupPeriod()const
{
return backupPeriod_;
}
void ModifyBackupStrategyRequest::setBackupPeriod(const std::string& backupPeriod)
{
backupPeriod_ = backupPeriod;
setCoreParameter("BackupPeriod", backupPeriod);
}
std::string ModifyBackupStrategyRequest::getBackupStartTime()const
{
return backupStartTime_;
}
void ModifyBackupStrategyRequest::setBackupStartTime(const std::string& backupStartTime)
{
backupStartTime_ = backupStartTime;
setCoreParameter("BackupStartTime", backupStartTime);
}

8
dbs/src/model/ModifyBackupStrategyResult.cc
View File

@@ -35,13 +35,9 @@ ModifyBackupStrategyResult::~ModifyBackupStrategyResult()
void ModifyBackupStrategyResult::parse(const std::string &payload)
{
Json::CharReaderBuilder builder;
Json::CharReader *reader = builder.newCharReader();
Json::Value *val;
Json::Reader reader;
Json::Value value;
JSONCPP_STRING *errs;
reader->parse(payload.data(), payload.data() + payload.size(), val, errs);
value = *val;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
if(!value["Success"].isNull())
success_ = value["Success"].asString() == "true";

11
dbs/src/model/RenewBackupPlanRequest.cc
View File

@@ -36,17 +36,6 @@ void RenewBackupPlanRequest::setPeriod(const std::string& period)
setCoreParameter("Period", period);
}
std::string RenewBackupPlanRequest::getRegionId()const
{
return regionId_;
}
void RenewBackupPlanRequest::setRegionId(const std::string& regionId)
{
regionId_ = regionId;
setCoreParameter("RegionId", regionId);
}
std::string RenewBackupPlanRequest::getClientToken()const
{
return clientToken_;

8
dbs/src/model/RenewBackupPlanResult.cc
View File

@@ -35,13 +35,9 @@ RenewBackupPlanResult::~RenewBackupPlanResult()
void RenewBackupPlanResult::parse(const std::string &payload)
{
Json::CharReaderBuilder builder;
Json::CharReader *reader = builder.newCharReader();
Json::Value *val;
Json::Reader reader;
Json::Value value;
JSONCPP_STRING *errs;
reader->parse(payload.data(), payload.data() + payload.size(), val, errs);
value = *val;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
if(!value["Success"].isNull())
success_ = value["Success"].asString() == "true";

11
dbs/src/model/StartBackupPlanRequest.cc
View File

@@ -25,17 +25,6 @@ StartBackupPlanRequest::StartBackupPlanRequest() :
StartBackupPlanRequest::~StartBackupPlanRequest()
{}
std::string StartBackupPlanRequest::getRegionId()const
{
return regionId_;
}
void StartBackupPlanRequest::setRegionId(const std::string& regionId)
{
regionId_ = regionId;
setCoreParameter("RegionId", regionId);
}
std::string StartBackupPlanRequest::getClientToken()const
{
return clientToken_;

8
dbs/src/model/StartBackupPlanResult.cc
View File

@@ -35,13 +35,9 @@ StartBackupPlanResult::~StartBackupPlanResult()
void StartBackupPlanResult::parse(const std::string &payload)
{
Json::CharReaderBuilder builder;
Json::CharReader *reader = builder.newCharReader();
Json::Value *val;
Json::Reader reader;
Json::Value value;
JSONCPP_STRING *errs;
reader->parse(payload.data(), payload.data() + payload.size(), val, errs);
value = *val;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
if(!value["Success"].isNull())
success_ = value["Success"].asString() == "true";

33
dbs/src/model/StartRestoreTaskRequest.cc
View File

@@ -25,17 +25,6 @@ StartRestoreTaskRequest::StartRestoreTaskRequest() :
StartRestoreTaskRequest::~StartRestoreTaskRequest()
{}
std::string StartRestoreTaskRequest::getRegionId()const
{
return regionId_;
}
void StartRestoreTaskRequest::setRegionId(const std::string& regionId)
{
regionId_ = regionId;
setCoreParameter("RegionId", regionId);
}
std::string StartRestoreTaskRequest::getClientToken()const
{
return clientToken_;
@@ -47,17 +36,6 @@ void StartRestoreTaskRequest::setClientToken(const std::string& clientToken)
setCoreParameter("ClientToken", clientToken);
}
std::string StartRestoreTaskRequest::getRestoreTaskId()const
{
return restoreTaskId_;
}
void StartRestoreTaskRequest::setRestoreTaskId(const std::string& restoreTaskId)
{
restoreTaskId_ = restoreTaskId;
setCoreParameter("RestoreTaskId", restoreTaskId);
}
std::string StartRestoreTaskRequest::getOwnerId()const
{
return ownerId_;
@@ -69,3 +47,14 @@ void StartRestoreTaskRequest::setOwnerId(const std::string& ownerId)
setCoreParameter("OwnerId", ownerId);
}
std::string StartRestoreTaskRequest::getRestoreTaskId()const
{
return restoreTaskId_;
}
void StartRestoreTaskRequest::setRestoreTaskId(const std::string& restoreTaskId)
{
restoreTaskId_ = restoreTaskId;
setCoreParameter("RestoreTaskId", restoreTaskId);
}

8
dbs/src/model/StartRestoreTaskResult.cc
View File

@@ -35,13 +35,9 @@ StartRestoreTaskResult::~StartRestoreTaskResult()
void StartRestoreTaskResult::parse(const std::string &payload)
{
Json::CharReaderBuilder builder;
Json::CharReader *reader = builder.newCharReader();
Json::Value *val;
Json::Reader reader;
Json::Value value;
JSONCPP_STRING *errs;
reader->parse(payload.data(), payload.data() + payload.size(), val, errs);
value = *val;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
if(!value["Success"].isNull())
success_ = value["Success"].asString() == "true";

11
dbs/src/model/StopBackupPlanRequest.cc
View File

@@ -36,17 +36,6 @@ void StopBackupPlanRequest::setStopMethod(const std::string& stopMethod)
setCoreParameter("StopMethod", stopMethod);
}
std::string StopBackupPlanRequest::getRegionId()const
{
return regionId_;
}
void StopBackupPlanRequest::setRegionId(const std::string& regionId)
{
regionId_ = regionId;
setCoreParameter("RegionId", regionId);
}
std::string StopBackupPlanRequest::getClientToken()const
{
return clientToken_;

8
dbs/src/model/StopBackupPlanResult.cc
View File

@@ -35,13 +35,9 @@ StopBackupPlanResult::~StopBackupPlanResult()
void StopBackupPlanResult::parse(const std::string &payload)
{
Json::CharReaderBuilder builder;
Json::CharReader *reader = builder.newCharReader();
Json::Value *val;
Json::Reader reader;
Json::Value value;
JSONCPP_STRING *errs;
reader->parse(payload.data(), payload.data() + payload.size(), val, errs);
value = *val;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
if(!value["Success"].isNull())
success_ = value["Success"].asString() == "true";

11
dbs/src/model/UpgradeBackupPlanRequest.cc
View File

@@ -25,17 +25,6 @@ UpgradeBackupPlanRequest::UpgradeBackupPlanRequest() :
UpgradeBackupPlanRequest::~UpgradeBackupPlanRequest()
{}
std::string UpgradeBackupPlanRequest::getRegionId()const
{
return regionId_;
}
void UpgradeBackupPlanRequest::setRegionId(const std::string& regionId)
{
regionId_ = regionId;
setCoreParameter("RegionId", regionId);
}
std::string UpgradeBackupPlanRequest::getClientToken()const
{
return clientToken_;

8
dbs/src/model/UpgradeBackupPlanResult.cc
View File

@@ -35,13 +35,9 @@ UpgradeBackupPlanResult::~UpgradeBackupPlanResult()
void UpgradeBackupPlanResult::parse(const std::string &payload)
{
Json::CharReaderBuilder builder;
Json::CharReader *reader = builder.newCharReader();
Json::Value *val;
Json::Reader reader;
Json::Value value;
JSONCPP_STRING *errs;
reader->parse(payload.data(), payload.data() + payload.size(), val, errs);
value = *val;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
if(!value["Success"].isNull())
success_ = value["Success"].asString() == "true";