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

CreateReplicationJob API supports the specified instance type.

Browse Source
This commit is contained in:
sdk-team
2019-11-27 18:05:30 +08:00
parent d499a02ffc
commit a25fc9202a
54 changed files with 4613 additions and 1 deletions
Download Patch File Download Diff File Expand all files Collapse all files

3
CHANGELOG
View File

@@ -1,3 +1,6 @@
2019-11-27 Version 1.36.200
- CreateReplicationJob API supports the specified instance type.
2019-11-26 Version 1.36.199
- Modify QueryBill, add SubOrderId in item of response.

2
VERSION
View File

@@ -1 +1 @@
1.36.199
1.36.200

130
smc/CMakeLists.txt Normal file
View File

@@ -0,0 +1,130 @@
#
# Copyright 2009-2017 Alibaba Cloud All rights reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
#
set(public_header_dir ${CMAKE_CURRENT_SOURCE_DIR}/../include)
set(smc_public_header
include/alibabacloud/smc/SmcClient.h
include/alibabacloud/smc/SmcExport.h )
set(smc_public_header_model
include/alibabacloud/smc/model/CreateReplicationJobRequest.h
include/alibabacloud/smc/model/CreateReplicationJobResult.h
include/alibabacloud/smc/model/DeleteReplicationJobRequest.h
include/alibabacloud/smc/model/DeleteReplicationJobResult.h
include/alibabacloud/smc/model/DeleteSourceServerRequest.h
include/alibabacloud/smc/model/DeleteSourceServerResult.h
include/alibabacloud/smc/model/DescribeReplicationJobsRequest.h
include/alibabacloud/smc/model/DescribeReplicationJobsResult.h
include/alibabacloud/smc/model/DescribeSourceServersRequest.h
include/alibabacloud/smc/model/DescribeSourceServersResult.h
include/alibabacloud/smc/model/ListTagResourcesRequest.h
include/alibabacloud/smc/model/ListTagResourcesResult.h
include/alibabacloud/smc/model/ModifyReplicationJobAttributeRequest.h
include/alibabacloud/smc/model/ModifyReplicationJobAttributeResult.h
include/alibabacloud/smc/model/ModifySourceServerAttributeRequest.h
include/alibabacloud/smc/model/ModifySourceServerAttributeResult.h
include/alibabacloud/smc/model/StartReplicationJobRequest.h
include/alibabacloud/smc/model/StartReplicationJobResult.h
include/alibabacloud/smc/model/StopReplicationJobRequest.h
include/alibabacloud/smc/model/StopReplicationJobResult.h
include/alibabacloud/smc/model/TagResourcesRequest.h
include/alibabacloud/smc/model/TagResourcesResult.h
include/alibabacloud/smc/model/UntagResourcesRequest.h
include/alibabacloud/smc/model/UntagResourcesResult.h )
set(smc_src
src/SmcClient.cc
src/model/CreateReplicationJobRequest.cc
src/model/CreateReplicationJobResult.cc
src/model/DeleteReplicationJobRequest.cc
src/model/DeleteReplicationJobResult.cc
src/model/DeleteSourceServerRequest.cc
src/model/DeleteSourceServerResult.cc
src/model/DescribeReplicationJobsRequest.cc
src/model/DescribeReplicationJobsResult.cc
src/model/DescribeSourceServersRequest.cc
src/model/DescribeSourceServersResult.cc
src/model/ListTagResourcesRequest.cc
src/model/ListTagResourcesResult.cc
src/model/ModifyReplicationJobAttributeRequest.cc
src/model/ModifyReplicationJobAttributeResult.cc
src/model/ModifySourceServerAttributeRequest.cc
src/model/ModifySourceServerAttributeResult.cc
src/model/StartReplicationJobRequest.cc
src/model/StartReplicationJobResult.cc
src/model/StopReplicationJobRequest.cc
src/model/StopReplicationJobResult.cc
src/model/TagResourcesRequest.cc
src/model/TagResourcesResult.cc
src/model/UntagResourcesRequest.cc
src/model/UntagResourcesResult.cc )
add_library(smc ${LIB_TYPE}
${smc_public_header}
${smc_public_header_model}
${smc_src})
set_target_properties(smc
PROPERTIES
LINKER_LANGUAGE CXX
ARCHIVE_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/lib
LIBRARY_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/lib
RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/bin
OUTPUT_NAME ${TARGET_OUTPUT_NAME_PREFIX}smc
)
if(${LIB_TYPE} STREQUAL "SHARED")
set_target_properties(smc
PROPERTIES
DEFINE_SYMBOL ALIBABACLOUD_SMC_LIBRARY)
endif()
target_include_directories(smc
PRIVATE include
${CMAKE_SOURCE_DIR}/core/include
)
target_link_libraries(smc
core)
if(CMAKE_HOST_WIN32)
ExternalProject_Get_Property(jsoncpp INSTALL_DIR)
set(jsoncpp_install_dir ${INSTALL_DIR})
add_dependencies(smc
jsoncpp)
target_include_directories(smc
PRIVATE ${jsoncpp_install_dir}/include)
target_link_libraries(smc
${jsoncpp_install_dir}/lib/jsoncpp.lib)
set_target_properties(smc
PROPERTIES
COMPILE_OPTIONS "/bigobj")
else()
target_include_directories(smc
PRIVATE /usr/include/jsoncpp)
target_link_libraries(smc
jsoncpp)
endif()
install(FILES ${smc_public_header}
DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/alibabacloud/smc)
install(FILES ${smc_public_header_model}
DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/alibabacloud/smc/model)
install(TARGETS smc
ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}
LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}
)

142
smc/include/alibabacloud/smc/SmcClient.h Normal file
View File

@@ -0,0 +1,142 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_SMC_SMCCLIENT_H_
#define ALIBABACLOUD_SMC_SMCCLIENT_H_
#include <future>
#include <alibabacloud/core/AsyncCallerContext.h>
#include <alibabacloud/core/EndpointProvider.h>
#include <alibabacloud/core/RpcServiceClient.h>
#include "SmcExport.h"
#include "model/CreateReplicationJobRequest.h"
#include "model/CreateReplicationJobResult.h"
#include "model/DeleteReplicationJobRequest.h"
#include "model/DeleteReplicationJobResult.h"
#include "model/DeleteSourceServerRequest.h"
#include "model/DeleteSourceServerResult.h"
#include "model/DescribeReplicationJobsRequest.h"
#include "model/DescribeReplicationJobsResult.h"
#include "model/DescribeSourceServersRequest.h"
#include "model/DescribeSourceServersResult.h"
#include "model/ListTagResourcesRequest.h"
#include "model/ListTagResourcesResult.h"
#include "model/ModifyReplicationJobAttributeRequest.h"
#include "model/ModifyReplicationJobAttributeResult.h"
#include "model/ModifySourceServerAttributeRequest.h"
#include "model/ModifySourceServerAttributeResult.h"
#include "model/StartReplicationJobRequest.h"
#include "model/StartReplicationJobResult.h"
#include "model/StopReplicationJobRequest.h"
#include "model/StopReplicationJobResult.h"
#include "model/TagResourcesRequest.h"
#include "model/TagResourcesResult.h"
#include "model/UntagResourcesRequest.h"
#include "model/UntagResourcesResult.h"
namespace AlibabaCloud
{
namespace Smc
{
class ALIBABACLOUD_SMC_EXPORT SmcClient : public RpcServiceClient
{
public:
typedef Outcome<Error, Model::CreateReplicationJobResult> CreateReplicationJobOutcome;
typedef std::future<CreateReplicationJobOutcome> CreateReplicationJobOutcomeCallable;
typedef std::function<void(const SmcClient*, const Model::CreateReplicationJobRequest&, const CreateReplicationJobOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateReplicationJobAsyncHandler;
typedef Outcome<Error, Model::DeleteReplicationJobResult> DeleteReplicationJobOutcome;
typedef std::future<DeleteReplicationJobOutcome> DeleteReplicationJobOutcomeCallable;
typedef std::function<void(const SmcClient*, const Model::DeleteReplicationJobRequest&, const DeleteReplicationJobOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteReplicationJobAsyncHandler;
typedef Outcome<Error, Model::DeleteSourceServerResult> DeleteSourceServerOutcome;
typedef std::future<DeleteSourceServerOutcome> DeleteSourceServerOutcomeCallable;
typedef std::function<void(const SmcClient*, const Model::DeleteSourceServerRequest&, const DeleteSourceServerOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteSourceServerAsyncHandler;
typedef Outcome<Error, Model::DescribeReplicationJobsResult> DescribeReplicationJobsOutcome;
typedef std::future<DescribeReplicationJobsOutcome> DescribeReplicationJobsOutcomeCallable;
typedef std::function<void(const SmcClient*, const Model::DescribeReplicationJobsRequest&, const DescribeReplicationJobsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeReplicationJobsAsyncHandler;
typedef Outcome<Error, Model::DescribeSourceServersResult> DescribeSourceServersOutcome;
typedef std::future<DescribeSourceServersOutcome> DescribeSourceServersOutcomeCallable;
typedef std::function<void(const SmcClient*, const Model::DescribeSourceServersRequest&, const DescribeSourceServersOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeSourceServersAsyncHandler;
typedef Outcome<Error, Model::ListTagResourcesResult> ListTagResourcesOutcome;
typedef std::future<ListTagResourcesOutcome> ListTagResourcesOutcomeCallable;
typedef std::function<void(const SmcClient*, const Model::ListTagResourcesRequest&, const ListTagResourcesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListTagResourcesAsyncHandler;
typedef Outcome<Error, Model::ModifyReplicationJobAttributeResult> ModifyReplicationJobAttributeOutcome;
typedef std::future<ModifyReplicationJobAttributeOutcome> ModifyReplicationJobAttributeOutcomeCallable;
typedef std::function<void(const SmcClient*, const Model::ModifyReplicationJobAttributeRequest&, const ModifyReplicationJobAttributeOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ModifyReplicationJobAttributeAsyncHandler;
typedef Outcome<Error, Model::ModifySourceServerAttributeResult> ModifySourceServerAttributeOutcome;
typedef std::future<ModifySourceServerAttributeOutcome> ModifySourceServerAttributeOutcomeCallable;
typedef std::function<void(const SmcClient*, const Model::ModifySourceServerAttributeRequest&, const ModifySourceServerAttributeOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ModifySourceServerAttributeAsyncHandler;
typedef Outcome<Error, Model::StartReplicationJobResult> StartReplicationJobOutcome;
typedef std::future<StartReplicationJobOutcome> StartReplicationJobOutcomeCallable;
typedef std::function<void(const SmcClient*, const Model::StartReplicationJobRequest&, const StartReplicationJobOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> StartReplicationJobAsyncHandler;
typedef Outcome<Error, Model::StopReplicationJobResult> StopReplicationJobOutcome;
typedef std::future<StopReplicationJobOutcome> StopReplicationJobOutcomeCallable;
typedef std::function<void(const SmcClient*, const Model::StopReplicationJobRequest&, const StopReplicationJobOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> StopReplicationJobAsyncHandler;
typedef Outcome<Error, Model::TagResourcesResult> TagResourcesOutcome;
typedef std::future<TagResourcesOutcome> TagResourcesOutcomeCallable;
typedef std::function<void(const SmcClient*, const Model::TagResourcesRequest&, const TagResourcesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> TagResourcesAsyncHandler;
typedef Outcome<Error, Model::UntagResourcesResult> UntagResourcesOutcome;
typedef std::future<UntagResourcesOutcome> UntagResourcesOutcomeCallable;
typedef std::function<void(const SmcClient*, const Model::UntagResourcesRequest&, const UntagResourcesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> UntagResourcesAsyncHandler;
SmcClient(const Credentials &credentials, const ClientConfiguration &configuration);
SmcClient(const std::shared_ptr<CredentialsProvider> &credentialsProvider, const ClientConfiguration &configuration);
SmcClient(const std::string &accessKeyId, const std::string &accessKeySecret, const ClientConfiguration &configuration);
~SmcClient();
CreateReplicationJobOutcome createReplicationJob(const Model::CreateReplicationJobRequest &request)const;
void createReplicationJobAsync(const Model::CreateReplicationJobRequest& request, const CreateReplicationJobAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
CreateReplicationJobOutcomeCallable createReplicationJobCallable(const Model::CreateReplicationJobRequest& request) const;
DeleteReplicationJobOutcome deleteReplicationJob(const Model::DeleteReplicationJobRequest &request)const;
void deleteReplicationJobAsync(const Model::DeleteReplicationJobRequest& request, const DeleteReplicationJobAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DeleteReplicationJobOutcomeCallable deleteReplicationJobCallable(const Model::DeleteReplicationJobRequest& request) const;
DeleteSourceServerOutcome deleteSourceServer(const Model::DeleteSourceServerRequest &request)const;
void deleteSourceServerAsync(const Model::DeleteSourceServerRequest& request, const DeleteSourceServerAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DeleteSourceServerOutcomeCallable deleteSourceServerCallable(const Model::DeleteSourceServerRequest& request) const;
DescribeReplicationJobsOutcome describeReplicationJobs(const Model::DescribeReplicationJobsRequest &request)const;
void describeReplicationJobsAsync(const Model::DescribeReplicationJobsRequest& request, const DescribeReplicationJobsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeReplicationJobsOutcomeCallable describeReplicationJobsCallable(const Model::DescribeReplicationJobsRequest& request) const;
DescribeSourceServersOutcome describeSourceServers(const Model::DescribeSourceServersRequest &request)const;
void describeSourceServersAsync(const Model::DescribeSourceServersRequest& request, const DescribeSourceServersAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeSourceServersOutcomeCallable describeSourceServersCallable(const Model::DescribeSourceServersRequest& request) const;
ListTagResourcesOutcome listTagResources(const Model::ListTagResourcesRequest &request)const;
void listTagResourcesAsync(const Model::ListTagResourcesRequest& request, const ListTagResourcesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
ListTagResourcesOutcomeCallable listTagResourcesCallable(const Model::ListTagResourcesRequest& request) const;
ModifyReplicationJobAttributeOutcome modifyReplicationJobAttribute(const Model::ModifyReplicationJobAttributeRequest &request)const;
void modifyReplicationJobAttributeAsync(const Model::ModifyReplicationJobAttributeRequest& request, const ModifyReplicationJobAttributeAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
ModifyReplicationJobAttributeOutcomeCallable modifyReplicationJobAttributeCallable(const Model::ModifyReplicationJobAttributeRequest& request) const;
ModifySourceServerAttributeOutcome modifySourceServerAttribute(const Model::ModifySourceServerAttributeRequest &request)const;
void modifySourceServerAttributeAsync(const Model::ModifySourceServerAttributeRequest& request, const ModifySourceServerAttributeAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
ModifySourceServerAttributeOutcomeCallable modifySourceServerAttributeCallable(const Model::ModifySourceServerAttributeRequest& request) const;
StartReplicationJobOutcome startReplicationJob(const Model::StartReplicationJobRequest &request)const;
void startReplicationJobAsync(const Model::StartReplicationJobRequest& request, const StartReplicationJobAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
StartReplicationJobOutcomeCallable startReplicationJobCallable(const Model::StartReplicationJobRequest& request) const;
StopReplicationJobOutcome stopReplicationJob(const Model::StopReplicationJobRequest &request)const;
void stopReplicationJobAsync(const Model::StopReplicationJobRequest& request, const StopReplicationJobAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
StopReplicationJobOutcomeCallable stopReplicationJobCallable(const Model::StopReplicationJobRequest& request) const;
TagResourcesOutcome tagResources(const Model::TagResourcesRequest &request)const;
void tagResourcesAsync(const Model::TagResourcesRequest& request, const TagResourcesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
TagResourcesOutcomeCallable tagResourcesCallable(const Model::TagResourcesRequest& request) const;
UntagResourcesOutcome untagResources(const Model::UntagResourcesRequest &request)const;
void untagResourcesAsync(const Model::UntagResourcesRequest& request, const UntagResourcesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
UntagResourcesOutcomeCallable untagResourcesCallable(const Model::UntagResourcesRequest& request) const;
private:
std::shared_ptr<EndpointProvider> endpointProvider_;
};
}
}
#endif // !ALIBABACLOUD_SMC_SMCCLIENT_H_

32
smc/include/alibabacloud/smc/SmcExport.h Normal file
View File

@@ -0,0 +1,32 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_SMC_SMCEXPORT_H_
#define ALIBABACLOUD_SMC_SMCEXPORT_H_
#include <alibabacloud/core/Global.h>
#if defined(ALIBABACLOUD_SHARED)
# if defined(ALIBABACLOUD_SMC_LIBRARY)
# define ALIBABACLOUD_SMC_EXPORT ALIBABACLOUD_DECL_EXPORT
# else
# define ALIBABACLOUD_SMC_EXPORT ALIBABACLOUD_DECL_IMPORT
# endif
#else
# define ALIBABACLOUD_SMC_EXPORT
#endif
#endif // !ALIBABACLOUD_SMC_SMCEXPORT_H_

127
smc/include/alibabacloud/smc/model/CreateReplicationJobRequest.h Normal file
View File

@@ -0,0 +1,127 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_SMC_MODEL_CREATEREPLICATIONJOBREQUEST_H_
#define ALIBABACLOUD_SMC_MODEL_CREATEREPLICATIONJOBREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/smc/SmcExport.h>
namespace AlibabaCloud
{
namespace Smc
{
namespace Model
{
class ALIBABACLOUD_SMC_EXPORT CreateReplicationJobRequest : public RpcServiceRequest
{
struct Tag
{
std::string value;
std::string key;
};
struct DataDisk
{
int size;
int index;
};
public:
CreateReplicationJobRequest();
~CreateReplicationJobRequest();
std::string getTargetType()const;
void setTargetType(const std::string& targetType);
std::string getClientToken()const;
void setClientToken(const std::string& clientToken);
std::string getDescription()const;
void setDescription(const std::string& description);
std::string getAccessKeyId()const;
void setAccessKeyId(const std::string& accessKeyId);
int getFrequency()const;
void setFrequency(int frequency);
std::string getReplicationParameters()const;
void setReplicationParameters(const std::string& replicationParameters);
std::string getRegionId()const;
void setRegionId(const std::string& regionId);
std::string getImageName()const;
void setImageName(const std::string& imageName);
int getSystemDiskSize()const;
void setSystemDiskSize(int systemDiskSize);
std::string getInstanceType()const;
void setInstanceType(const std::string& instanceType);
std::vector<Tag> getTag()const;
void setTag(const std::vector<Tag>& tag);
int getNetMode()const;
void setNetMode(int netMode);
std::string getSourceId()const;
void setSourceId(const std::string& sourceId);
bool getRunOnce()const;
void setRunOnce(bool runOnce);
std::string getResourceOwnerAccount()const;
void setResourceOwnerAccount(const std::string& resourceOwnerAccount);
std::string getValidTime()const;
void setValidTime(const std::string& validTime);
long getOwnerId()const;
void setOwnerId(long ownerId);
std::vector<DataDisk> getDataDisk()const;
void setDataDisk(const std::vector<DataDisk>& dataDisk);
std::string getVSwitchId()const;
void setVSwitchId(const std::string& vSwitchId);
std::string getScheduledStartTime()const;
void setScheduledStartTime(const std::string& scheduledStartTime);
std::string getInstanceId()const;
void setInstanceId(const std::string& instanceId);
std::string getVpcId()const;
void setVpcId(const std::string& vpcId);
std::string getName()const;
void setName(const std::string& name);
int getMaxNumberOfImageToKeep()const;
void setMaxNumberOfImageToKeep(int maxNumberOfImageToKeep);
private:
std::string targetType_;
std::string clientToken_;
std::string description_;
std::string accessKeyId_;
int frequency_;
std::string replicationParameters_;
std::string regionId_;
std::string imageName_;
int systemDiskSize_;
std::string instanceType_;
std::vector<Tag> tag_;
int netMode_;
std::string sourceId_;
bool runOnce_;
std::string resourceOwnerAccount_;
std::string validTime_;
long ownerId_;
std::vector<DataDisk> dataDisk_;
std::string vSwitchId_;
std::string scheduledStartTime_;
std::string instanceId_;
std::string vpcId_;
std::string name_;
int maxNumberOfImageToKeep_;
};
}
}
}
#endif // !ALIBABACLOUD_SMC_MODEL_CREATEREPLICATIONJOBREQUEST_H_

51
smc/include/alibabacloud/smc/model/CreateReplicationJobResult.h Normal file
View File

@@ -0,0 +1,51 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_SMC_MODEL_CREATEREPLICATIONJOBRESULT_H_
#define ALIBABACLOUD_SMC_MODEL_CREATEREPLICATIONJOBRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/smc/SmcExport.h>
namespace AlibabaCloud
{
namespace Smc
{
namespace Model
{
class ALIBABACLOUD_SMC_EXPORT CreateReplicationJobResult : public ServiceResult
{
public:
CreateReplicationJobResult();
explicit CreateReplicationJobResult(const std::string &payload);
~CreateReplicationJobResult();
std::string getJobId()const;
protected:
void parse(const std::string &payload);
private:
std::string jobId_;
};
}
}
}
#endif // !ALIBABACLOUD_SMC_MODEL_CREATEREPLICATIONJOBRESULT_H_

57
smc/include/alibabacloud/smc/model/DeleteReplicationJobRequest.h Normal file
View File

@@ -0,0 +1,57 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_SMC_MODEL_DELETEREPLICATIONJOBREQUEST_H_
#define ALIBABACLOUD_SMC_MODEL_DELETEREPLICATIONJOBREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/smc/SmcExport.h>
namespace AlibabaCloud
{
namespace Smc
{
namespace Model
{
class ALIBABACLOUD_SMC_EXPORT DeleteReplicationJobRequest : public RpcServiceRequest
{
public:
DeleteReplicationJobRequest();
~DeleteReplicationJobRequest();
std::string getResourceOwnerAccount()const;
void setResourceOwnerAccount(const std::string& resourceOwnerAccount);
long getOwnerId()const;
void setOwnerId(long ownerId);
std::string getAccessKeyId()const;
void setAccessKeyId(const std::string& accessKeyId);
std::string getJobId()const;
void setJobId(const std::string& jobId);
private:
std::string resourceOwnerAccount_;
long ownerId_;
std::string accessKeyId_;
std::string jobId_;
};
}
}
}
#endif // !ALIBABACLOUD_SMC_MODEL_DELETEREPLICATIONJOBREQUEST_H_

49
smc/include/alibabacloud/smc/model/DeleteReplicationJobResult.h Normal file
View File

@@ -0,0 +1,49 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_SMC_MODEL_DELETEREPLICATIONJOBRESULT_H_
#define ALIBABACLOUD_SMC_MODEL_DELETEREPLICATIONJOBRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/smc/SmcExport.h>
namespace AlibabaCloud
{
namespace Smc
{
namespace Model
{
class ALIBABACLOUD_SMC_EXPORT DeleteReplicationJobResult : public ServiceResult
{
public:
DeleteReplicationJobResult();
explicit DeleteReplicationJobResult(const std::string &payload);
~DeleteReplicationJobResult();
protected:
void parse(const std::string &payload);
private:
};
}
}
}
#endif // !ALIBABACLOUD_SMC_MODEL_DELETEREPLICATIONJOBRESULT_H_

60
smc/include/alibabacloud/smc/model/DeleteSourceServerRequest.h Normal file
View File

@@ -0,0 +1,60 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_SMC_MODEL_DELETESOURCESERVERREQUEST_H_
#define ALIBABACLOUD_SMC_MODEL_DELETESOURCESERVERREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/smc/SmcExport.h>
namespace AlibabaCloud
{
namespace Smc
{
namespace Model
{
class ALIBABACLOUD_SMC_EXPORT DeleteSourceServerRequest : public RpcServiceRequest
{
public:
DeleteSourceServerRequest();
~DeleteSourceServerRequest();
std::string getSourceId()const;
void setSourceId(const std::string& sourceId);
std::string getResourceOwnerAccount()const;
void setResourceOwnerAccount(const std::string& resourceOwnerAccount);
long getOwnerId()const;
void setOwnerId(long ownerId);
std::string getAccessKeyId()const;
void setAccessKeyId(const std::string& accessKeyId);
bool getForce()const;
void setForce(bool force);
private:
std::string sourceId_;
std::string resourceOwnerAccount_;
long ownerId_;
std::string accessKeyId_;
bool force_;
};
}
}
}
#endif // !ALIBABACLOUD_SMC_MODEL_DELETESOURCESERVERREQUEST_H_

49
smc/include/alibabacloud/smc/model/DeleteSourceServerResult.h Normal file
View File

@@ -0,0 +1,49 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_SMC_MODEL_DELETESOURCESERVERRESULT_H_
#define ALIBABACLOUD_SMC_MODEL_DELETESOURCESERVERRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/smc/SmcExport.h>
namespace AlibabaCloud
{
namespace Smc
{
namespace Model
{
class ALIBABACLOUD_SMC_EXPORT DeleteSourceServerResult : public ServiceResult
{
public:
DeleteSourceServerResult();
explicit DeleteSourceServerResult(const std::string &payload);
~DeleteSourceServerResult();
protected:
void parse(const std::string &payload);
private:
};
}
}
}
#endif // !ALIBABACLOUD_SMC_MODEL_DELETESOURCESERVERRESULT_H_

78
smc/include/alibabacloud/smc/model/DescribeReplicationJobsRequest.h Normal file
View File

@@ -0,0 +1,78 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_SMC_MODEL_DESCRIBEREPLICATIONJOBSREQUEST_H_
#define ALIBABACLOUD_SMC_MODEL_DESCRIBEREPLICATIONJOBSREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/smc/SmcExport.h>
namespace AlibabaCloud
{
namespace Smc
{
namespace Model
{
class ALIBABACLOUD_SMC_EXPORT DescribeReplicationJobsRequest : public RpcServiceRequest
{
public:
DescribeReplicationJobsRequest();
~DescribeReplicationJobsRequest();
int getPageNumber()const;
void setPageNumber(int pageNumber);
std::string getAccessKeyId()const;
void setAccessKeyId(const std::string& accessKeyId);
std::vector<std::string> getJobId()const;
void setJobId(const std::vector<std::string>& jobId);
std::string getRegionId()const;
void setRegionId(const std::string& regionId);
int getPageSize()const;
void setPageSize(int pageSize);
std::vector<std::string> getSourceId()const;
void setSourceId(const std::vector<std::string>& sourceId);
std::string getBusinessStatus()const;
void setBusinessStatus(const std::string& businessStatus);
std::string getResourceOwnerAccount()const;
void setResourceOwnerAccount(const std::string& resourceOwnerAccount);
long getOwnerId()const;
void setOwnerId(long ownerId);
std::string getName()const;
void setName(const std::string& name);
std::string getStatus()const;
void setStatus(const std::string& status);
private:
int pageNumber_;
std::string accessKeyId_;
std::vector<std::string> jobId_;
std::string regionId_;
int pageSize_;
std::vector<std::string> sourceId_;
std::string businessStatus_;
std::string resourceOwnerAccount_;
long ownerId_;
std::string name_;
std::string status_;
};
}
}
}
#endif // !ALIBABACLOUD_SMC_MODEL_DESCRIBEREPLICATIONJOBSREQUEST_H_

103
smc/include/alibabacloud/smc/model/DescribeReplicationJobsResult.h Normal file
View File

@@ -0,0 +1,103 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_SMC_MODEL_DESCRIBEREPLICATIONJOBSRESULT_H_
#define ALIBABACLOUD_SMC_MODEL_DESCRIBEREPLICATIONJOBSRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/smc/SmcExport.h>
namespace AlibabaCloud
{
namespace Smc
{
namespace Model
{
class ALIBABACLOUD_SMC_EXPORT DescribeReplicationJobsResult : public ServiceResult
{
public:
struct ReplicationJob
{
struct DataDisk
{
int size;
int index;
};
struct ReplicationJobRun
{
std::string type;
std::string endTime;
std::string imageId;
std::string startTime;
};
std::string description;
std::vector<ReplicationJob::DataDisk> dataDisks;
std::string endTime;
std::string transitionInstanceId;
int systemDiskSize;
int netMode;
std::string sourceId;
std::string businessStatus;
std::string name;
std::string validTime;
int maxNumberOfImageToKeep;
bool runOnce;
std::string targetType;
std::string imageId;
std::string instanceType;
std::vector<ReplicationJob::ReplicationJobRun> replicationJobRuns;
std::string jobId;
std::string status;
float progress;
std::string instanceId;
std::string vSwitchId;
std::string startTime;
std::string replicationParameters;
std::string imageName;
std::string vpcId;
std::string statusInfo;
std::string creationTime;
int frequency;
std::string regionId;
std::string scheduledStartTime;
std::string errorCode;
};
DescribeReplicationJobsResult();
explicit DescribeReplicationJobsResult(const std::string &payload);
~DescribeReplicationJobsResult();
int getTotalCount()const;
std::vector<ReplicationJob> getReplicationJobs()const;
int getPageSize()const;
int getPageNumber()const;
protected:
void parse(const std::string &payload);
private:
int totalCount_;
std::vector<ReplicationJob> replicationJobs_;
int pageSize_;
int pageNumber_;
};
}
}
}
#endif // !ALIBABACLOUD_SMC_MODEL_DESCRIBEREPLICATIONJOBSRESULT_H_

72
smc/include/alibabacloud/smc/model/DescribeSourceServersRequest.h Normal file
View File

@@ -0,0 +1,72 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_SMC_MODEL_DESCRIBESOURCESERVERSREQUEST_H_
#define ALIBABACLOUD_SMC_MODEL_DESCRIBESOURCESERVERSREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/smc/SmcExport.h>
namespace AlibabaCloud
{
namespace Smc
{
namespace Model
{
class ALIBABACLOUD_SMC_EXPORT DescribeSourceServersRequest : public RpcServiceRequest
{
public:
DescribeSourceServersRequest();
~DescribeSourceServersRequest();
int getPageNumber()const;
void setPageNumber(int pageNumber);
std::string getAccessKeyId()const;
void setAccessKeyId(const std::string& accessKeyId);
std::string getJobId()const;
void setJobId(const std::string& jobId);
int getPageSize()const;
void setPageSize(int pageSize);
std::string getState()const;
void setState(const std::string& state);
std::vector<std::string> getSourceId()const;
void setSourceId(const std::vector<std::string>& sourceId);
std::string getResourceOwnerAccount()const;
void setResourceOwnerAccount(const std::string& resourceOwnerAccount);
long getOwnerId()const;
void setOwnerId(long ownerId);
std::string getName()const;
void setName(const std::string& name);
private:
int pageNumber_;
std::string accessKeyId_;
std::string jobId_;
int pageSize_;
std::string state_;
std::vector<std::string> sourceId_;
std::string resourceOwnerAccount_;
long ownerId_;
std::string name_;
};
}
}
}
#endif // !ALIBABACLOUD_SMC_MODEL_DESCRIBESOURCESERVERSREQUEST_H_

83
smc/include/alibabacloud/smc/model/DescribeSourceServersResult.h Normal file
View File

@@ -0,0 +1,83 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_SMC_MODEL_DESCRIBESOURCESERVERSRESULT_H_
#define ALIBABACLOUD_SMC_MODEL_DESCRIBESOURCESERVERSRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/smc/SmcExport.h>
namespace AlibabaCloud
{
namespace Smc
{
namespace Model
{
class ALIBABACLOUD_SMC_EXPORT DescribeSourceServersResult : public ServiceResult
{
public:
struct SourceServer
{
struct DataDisk
{
std::string path;
int size;
int index;
};
std::string description;
std::string systemInfo;
std::vector<SourceServer::DataDisk> dataDisks;
std::string platform;
std::string architecture;
std::string agentVersion;
int systemDiskSize;
std::string sourceId;
std::string name;
int kernelLevel;
std::string replicationDriver;
std::string statusInfo;
std::string state;
std::string creationTime;
int heartbeatRate;
std::string errorCode;
std::string jobId;
};
DescribeSourceServersResult();
explicit DescribeSourceServersResult(const std::string &payload);
~DescribeSourceServersResult();
std::vector<SourceServer> getSourceServers()const;
int getTotalCount()const;
int getPageSize()const;
int getPageNumber()const;
protected:
void parse(const std::string &payload);
private:
std::vector<SourceServer> sourceServers_;
int totalCount_;
int pageSize_;
int pageNumber_;
};
}
}
}
#endif // !ALIBABACLOUD_SMC_MODEL_DESCRIBESOURCESERVERSRESULT_H_

71
smc/include/alibabacloud/smc/model/ListTagResourcesRequest.h Normal file
View File

@@ -0,0 +1,71 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_SMC_MODEL_LISTTAGRESOURCESREQUEST_H_
#define ALIBABACLOUD_SMC_MODEL_LISTTAGRESOURCESREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/smc/SmcExport.h>
namespace AlibabaCloud
{
namespace Smc
{
namespace Model
{
class ALIBABACLOUD_SMC_EXPORT ListTagResourcesRequest : public RpcServiceRequest
{
struct Tag
{
std::string value;
std::string key;
};
public:
ListTagResourcesRequest();
~ListTagResourcesRequest();
std::string getAccessKeyId()const;
void setAccessKeyId(const std::string& accessKeyId);
std::string getNextToken()const;
void setNextToken(const std::string& nextToken);
std::vector<Tag> getTag()const;
void setTag(const std::vector<Tag>& tag);
std::vector<std::string> getResourceId()const;
void setResourceId(const std::vector<std::string>& resourceId);
std::string getResourceOwnerAccount()const;
void setResourceOwnerAccount(const std::string& resourceOwnerAccount);
long getOwnerId()const;
void setOwnerId(long ownerId);
std::string getResourceType()const;
void setResourceType(const std::string& resourceType);
private:
std::string accessKeyId_;
std::string nextToken_;
std::vector<Tag> tag_;
std::vector<std::string> resourceId_;
std::string resourceOwnerAccount_;
long ownerId_;
std::string resourceType_;
};
}
}
}
#endif // !ALIBABACLOUD_SMC_MODEL_LISTTAGRESOURCESREQUEST_H_

60
smc/include/alibabacloud/smc/model/ListTagResourcesResult.h Normal file
View File

@@ -0,0 +1,60 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_SMC_MODEL_LISTTAGRESOURCESRESULT_H_
#define ALIBABACLOUD_SMC_MODEL_LISTTAGRESOURCESRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/smc/SmcExport.h>
namespace AlibabaCloud
{
namespace Smc
{
namespace Model
{
class ALIBABACLOUD_SMC_EXPORT ListTagResourcesResult : public ServiceResult
{
public:
struct TagResource
{
std::string resourceId;
std::string tagKey;
std::string resourceType;
std::string tagValue;
};
ListTagResourcesResult();
explicit ListTagResourcesResult(const std::string &payload);
~ListTagResourcesResult();
std::string getNextToken()const;
std::vector<TagResource> getTagResources()const;
protected:
void parse(const std::string &payload);
private:
std::string nextToken_;
std::vector<TagResource> tagResources_;
};
}
}
}
#endif // !ALIBABACLOUD_SMC_MODEL_LISTTAGRESOURCESRESULT_H_

95
smc/include/alibabacloud/smc/model/ModifyReplicationJobAttributeRequest.h Normal file
View File

@@ -0,0 +1,95 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_SMC_MODEL_MODIFYREPLICATIONJOBATTRIBUTEREQUEST_H_
#define ALIBABACLOUD_SMC_MODEL_MODIFYREPLICATIONJOBATTRIBUTEREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/smc/SmcExport.h>
namespace AlibabaCloud
{
namespace Smc
{
namespace Model
{
class ALIBABACLOUD_SMC_EXPORT ModifyReplicationJobAttributeRequest : public RpcServiceRequest
{
struct DataDisk
{
int size;
int index;
};
public:
ModifyReplicationJobAttributeRequest();
~ModifyReplicationJobAttributeRequest();
std::string getTargetType()const;
void setTargetType(const std::string& targetType);
std::string getDescription()const;
void setDescription(const std::string& description);
std::string getAccessKeyId()const;
void setAccessKeyId(const std::string& accessKeyId);
int getFrequency()const;
void setFrequency(int frequency);
std::string getJobId()const;
void setJobId(const std::string& jobId);
std::string getImageName()const;
void setImageName(const std::string& imageName);
int getSystemDiskSize()const;
void setSystemDiskSize(int systemDiskSize);
std::string getInstanceType()const;
void setInstanceType(const std::string& instanceType);
std::string getResourceOwnerAccount()const;
void setResourceOwnerAccount(const std::string& resourceOwnerAccount);
long getOwnerId()const;
void setOwnerId(long ownerId);
std::vector<DataDisk> getDataDisk()const;
void setDataDisk(const std::vector<DataDisk>& dataDisk);
std::string getScheduledStartTime()const;
void setScheduledStartTime(const std::string& scheduledStartTime);
std::string getInstanceId()const;
void setInstanceId(const std::string& instanceId);
std::string getName()const;
void setName(const std::string& name);
int getMaxNumberOfImageToKeep()const;
void setMaxNumberOfImageToKeep(int maxNumberOfImageToKeep);
private:
std::string targetType_;
std::string description_;
std::string accessKeyId_;
int frequency_;
std::string jobId_;
std::string imageName_;
int systemDiskSize_;
std::string instanceType_;
std::string resourceOwnerAccount_;
long ownerId_;
std::vector<DataDisk> dataDisk_;
std::string scheduledStartTime_;
std::string instanceId_;
std::string name_;
int maxNumberOfImageToKeep_;
};
}
}
}
#endif // !ALIBABACLOUD_SMC_MODEL_MODIFYREPLICATIONJOBATTRIBUTEREQUEST_H_

49
smc/include/alibabacloud/smc/model/ModifyReplicationJobAttributeResult.h Normal file
View File

@@ -0,0 +1,49 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_SMC_MODEL_MODIFYREPLICATIONJOBATTRIBUTERESULT_H_
#define ALIBABACLOUD_SMC_MODEL_MODIFYREPLICATIONJOBATTRIBUTERESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/smc/SmcExport.h>
namespace AlibabaCloud
{
namespace Smc
{
namespace Model
{
class ALIBABACLOUD_SMC_EXPORT ModifyReplicationJobAttributeResult : public ServiceResult
{
public:
ModifyReplicationJobAttributeResult();
explicit ModifyReplicationJobAttributeResult(const std::string &payload);
~ModifyReplicationJobAttributeResult();
protected:
void parse(const std::string &payload);
private:
};
}
}
}
#endif // !ALIBABACLOUD_SMC_MODEL_MODIFYREPLICATIONJOBATTRIBUTERESULT_H_

63
smc/include/alibabacloud/smc/model/ModifySourceServerAttributeRequest.h Normal file
View File

@@ -0,0 +1,63 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_SMC_MODEL_MODIFYSOURCESERVERATTRIBUTEREQUEST_H_
#define ALIBABACLOUD_SMC_MODEL_MODIFYSOURCESERVERATTRIBUTEREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/smc/SmcExport.h>
namespace AlibabaCloud
{
namespace Smc
{
namespace Model
{
class ALIBABACLOUD_SMC_EXPORT ModifySourceServerAttributeRequest : public RpcServiceRequest
{
public:
ModifySourceServerAttributeRequest();
~ModifySourceServerAttributeRequest();
std::string getDescription()const;
void setDescription(const std::string& description);
std::string getAccessKeyId()const;
void setAccessKeyId(const std::string& accessKeyId);
std::string getSourceId()const;
void setSourceId(const std::string& sourceId);
std::string getResourceOwnerAccount()const;
void setResourceOwnerAccount(const std::string& resourceOwnerAccount);
long getOwnerId()const;
void setOwnerId(long ownerId);
std::string getName()const;
void setName(const std::string& name);
private:
std::string description_;
std::string accessKeyId_;
std::string sourceId_;
std::string resourceOwnerAccount_;
long ownerId_;
std::string name_;
};
}
}
}
#endif // !ALIBABACLOUD_SMC_MODEL_MODIFYSOURCESERVERATTRIBUTEREQUEST_H_

49
smc/include/alibabacloud/smc/model/ModifySourceServerAttributeResult.h Normal file
View File

@@ -0,0 +1,49 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_SMC_MODEL_MODIFYSOURCESERVERATTRIBUTERESULT_H_
#define ALIBABACLOUD_SMC_MODEL_MODIFYSOURCESERVERATTRIBUTERESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/smc/SmcExport.h>
namespace AlibabaCloud
{
namespace Smc
{
namespace Model
{
class ALIBABACLOUD_SMC_EXPORT ModifySourceServerAttributeResult : public ServiceResult
{
public:
ModifySourceServerAttributeResult();
explicit ModifySourceServerAttributeResult(const std::string &payload);
~ModifySourceServerAttributeResult();
protected:
void parse(const std::string &payload);
private:
};
}
}
}
#endif // !ALIBABACLOUD_SMC_MODEL_MODIFYSOURCESERVERATTRIBUTERESULT_H_

57
smc/include/alibabacloud/smc/model/StartReplicationJobRequest.h Normal file
View File

@@ -0,0 +1,57 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_SMC_MODEL_STARTREPLICATIONJOBREQUEST_H_
#define ALIBABACLOUD_SMC_MODEL_STARTREPLICATIONJOBREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/smc/SmcExport.h>
namespace AlibabaCloud
{
namespace Smc
{
namespace Model
{
class ALIBABACLOUD_SMC_EXPORT StartReplicationJobRequest : public RpcServiceRequest
{
public:
StartReplicationJobRequest();
~StartReplicationJobRequest();
std::string getResourceOwnerAccount()const;
void setResourceOwnerAccount(const std::string& resourceOwnerAccount);
long getOwnerId()const;
void setOwnerId(long ownerId);
std::string getAccessKeyId()const;
void setAccessKeyId(const std::string& accessKeyId);
std::string getJobId()const;
void setJobId(const std::string& jobId);
private:
std::string resourceOwnerAccount_;
long ownerId_;
std::string accessKeyId_;
std::string jobId_;
};
}
}
}
#endif // !ALIBABACLOUD_SMC_MODEL_STARTREPLICATIONJOBREQUEST_H_

49
smc/include/alibabacloud/smc/model/StartReplicationJobResult.h Normal file
View File

@@ -0,0 +1,49 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_SMC_MODEL_STARTREPLICATIONJOBRESULT_H_
#define ALIBABACLOUD_SMC_MODEL_STARTREPLICATIONJOBRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/smc/SmcExport.h>
namespace AlibabaCloud
{
namespace Smc
{
namespace Model
{
class ALIBABACLOUD_SMC_EXPORT StartReplicationJobResult : public ServiceResult
{
public:
StartReplicationJobResult();
explicit StartReplicationJobResult(const std::string &payload);
~StartReplicationJobResult();
protected:
void parse(const std::string &payload);
private:
};
}
}
}
#endif // !ALIBABACLOUD_SMC_MODEL_STARTREPLICATIONJOBRESULT_H_

57
smc/include/alibabacloud/smc/model/StopReplicationJobRequest.h Normal file
View File

@@ -0,0 +1,57 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_SMC_MODEL_STOPREPLICATIONJOBREQUEST_H_
#define ALIBABACLOUD_SMC_MODEL_STOPREPLICATIONJOBREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/smc/SmcExport.h>
namespace AlibabaCloud
{
namespace Smc
{
namespace Model
{
class ALIBABACLOUD_SMC_EXPORT StopReplicationJobRequest : public RpcServiceRequest
{
public:
StopReplicationJobRequest();
~StopReplicationJobRequest();
std::string getResourceOwnerAccount()const;
void setResourceOwnerAccount(const std::string& resourceOwnerAccount);
long getOwnerId()const;
void setOwnerId(long ownerId);
std::string getAccessKeyId()const;
void setAccessKeyId(const std::string& accessKeyId);
std::string getJobId()const;
void setJobId(const std::string& jobId);
private:
std::string resourceOwnerAccount_;
long ownerId_;
std::string accessKeyId_;
std::string jobId_;
};
}
}
}
#endif // !ALIBABACLOUD_SMC_MODEL_STOPREPLICATIONJOBREQUEST_H_

49
smc/include/alibabacloud/smc/model/StopReplicationJobResult.h Normal file
View File

@@ -0,0 +1,49 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_SMC_MODEL_STOPREPLICATIONJOBRESULT_H_
#define ALIBABACLOUD_SMC_MODEL_STOPREPLICATIONJOBRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/smc/SmcExport.h>
namespace AlibabaCloud
{
namespace Smc
{
namespace Model
{
class ALIBABACLOUD_SMC_EXPORT StopReplicationJobResult : public ServiceResult
{
public:
StopReplicationJobResult();
explicit StopReplicationJobResult(const std::string &payload);
~StopReplicationJobResult();
protected:
void parse(const std::string &payload);
private:
};
}
}
}
#endif // !ALIBABACLOUD_SMC_MODEL_STOPREPLICATIONJOBRESULT_H_

68
smc/include/alibabacloud/smc/model/TagResourcesRequest.h Normal file
View File

@@ -0,0 +1,68 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_SMC_MODEL_TAGRESOURCESREQUEST_H_
#define ALIBABACLOUD_SMC_MODEL_TAGRESOURCESREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/smc/SmcExport.h>
namespace AlibabaCloud
{
namespace Smc
{
namespace Model
{
class ALIBABACLOUD_SMC_EXPORT TagResourcesRequest : public RpcServiceRequest
{
struct Tag
{
std::string value;
std::string key;
};
public:
TagResourcesRequest();
~TagResourcesRequest();
std::string getAccessKeyId()const;
void setAccessKeyId(const std::string& accessKeyId);
std::vector<Tag> getTag()const;
void setTag(const std::vector<Tag>& tag);
std::vector<std::string> getResourceId()const;
void setResourceId(const std::vector<std::string>& resourceId);
std::string getResourceOwnerAccount()const;
void setResourceOwnerAccount(const std::string& resourceOwnerAccount);
long getOwnerId()const;
void setOwnerId(long ownerId);
std::string getResourceType()const;
void setResourceType(const std::string& resourceType);
private:
std::string accessKeyId_;
std::vector<Tag> tag_;
std::vector<std::string> resourceId_;
std::string resourceOwnerAccount_;
long ownerId_;
std::string resourceType_;
};
}
}
}
#endif // !ALIBABACLOUD_SMC_MODEL_TAGRESOURCESREQUEST_H_

49
smc/include/alibabacloud/smc/model/TagResourcesResult.h Normal file
View File

@@ -0,0 +1,49 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_SMC_MODEL_TAGRESOURCESRESULT_H_
#define ALIBABACLOUD_SMC_MODEL_TAGRESOURCESRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/smc/SmcExport.h>
namespace AlibabaCloud
{
namespace Smc
{
namespace Model
{
class ALIBABACLOUD_SMC_EXPORT TagResourcesResult : public ServiceResult
{
public:
TagResourcesResult();
explicit TagResourcesResult(const std::string &payload);
~TagResourcesResult();
protected:
void parse(const std::string &payload);
private:
};
}
}
}
#endif // !ALIBABACLOUD_SMC_MODEL_TAGRESOURCESRESULT_H_

66
smc/include/alibabacloud/smc/model/UntagResourcesRequest.h Normal file
View File

@@ -0,0 +1,66 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_SMC_MODEL_UNTAGRESOURCESREQUEST_H_
#define ALIBABACLOUD_SMC_MODEL_UNTAGRESOURCESREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/smc/SmcExport.h>
namespace AlibabaCloud
{
namespace Smc
{
namespace Model
{
class ALIBABACLOUD_SMC_EXPORT UntagResourcesRequest : public RpcServiceRequest
{
public:
UntagResourcesRequest();
~UntagResourcesRequest();
std::string getAccessKeyId()const;
void setAccessKeyId(const std::string& accessKeyId);
bool getAll()const;
void setAll(bool all);
std::vector<std::string> getResourceId()const;
void setResourceId(const std::vector<std::string>& resourceId);
std::string getResourceOwnerAccount()const;
void setResourceOwnerAccount(const std::string& resourceOwnerAccount);
long getOwnerId()const;
void setOwnerId(long ownerId);
std::string getResourceType()const;
void setResourceType(const std::string& resourceType);
std::vector<std::string> getTagKey()const;
void setTagKey(const std::vector<std::string>& tagKey);
private:
std::string accessKeyId_;
bool all_;
std::vector<std::string> resourceId_;
std::string resourceOwnerAccount_;
long ownerId_;
std::string resourceType_;
std::vector<std::string> tagKey_;
};
}
}
}
#endif // !ALIBABACLOUD_SMC_MODEL_UNTAGRESOURCESREQUEST_H_

49
smc/include/alibabacloud/smc/model/UntagResourcesResult.h Normal file
View File

@@ -0,0 +1,49 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_SMC_MODEL_UNTAGRESOURCESRESULT_H_
#define ALIBABACLOUD_SMC_MODEL_UNTAGRESOURCESRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/smc/SmcExport.h>
namespace AlibabaCloud
{
namespace Smc
{
namespace Model
{
class ALIBABACLOUD_SMC_EXPORT UntagResourcesResult : public ServiceResult
{
public:
UntagResourcesResult();
explicit UntagResourcesResult(const std::string &payload);
~UntagResourcesResult();
protected:
void parse(const std::string &payload);
private:
};
}
}
}
#endif // !ALIBABACLOUD_SMC_MODEL_UNTAGRESOURCESRESULT_H_

485
smc/src/SmcClient.cc Normal file
View File

@@ -0,0 +1,485 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/smc/SmcClient.h>
#include <alibabacloud/core/SimpleCredentialsProvider.h>
using namespace AlibabaCloud;
using namespace AlibabaCloud::Location;
using namespace AlibabaCloud::Smc;
using namespace AlibabaCloud::Smc::Model;
namespace
{
const std::string SERVICE_NAME = "smc";
}
SmcClient::SmcClient(const Credentials &credentials, const ClientConfiguration &configuration) :
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, "smc");
}
SmcClient::SmcClient(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, "smc");
}
SmcClient::SmcClient(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, "smc");
}
SmcClient::~SmcClient()
{}
SmcClient::CreateReplicationJobOutcome SmcClient::createReplicationJob(const CreateReplicationJobRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return CreateReplicationJobOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return CreateReplicationJobOutcome(CreateReplicationJobResult(outcome.result()));
else
return CreateReplicationJobOutcome(outcome.error());
}
void SmcClient::createReplicationJobAsync(const CreateReplicationJobRequest& request, const CreateReplicationJobAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, createReplicationJob(request), context);
};
asyncExecute(new Runnable(fn));
}
SmcClient::CreateReplicationJobOutcomeCallable SmcClient::createReplicationJobCallable(const CreateReplicationJobRequest &request) const
{
auto task = std::make_shared<std::packaged_task<CreateReplicationJobOutcome()>>(
[this, request]()
{
return this->createReplicationJob(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
SmcClient::DeleteReplicationJobOutcome SmcClient::deleteReplicationJob(const DeleteReplicationJobRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return DeleteReplicationJobOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return DeleteReplicationJobOutcome(DeleteReplicationJobResult(outcome.result()));
else
return DeleteReplicationJobOutcome(outcome.error());
}
void SmcClient::deleteReplicationJobAsync(const DeleteReplicationJobRequest& request, const DeleteReplicationJobAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, deleteReplicationJob(request), context);
};
asyncExecute(new Runnable(fn));
}
SmcClient::DeleteReplicationJobOutcomeCallable SmcClient::deleteReplicationJobCallable(const DeleteReplicationJobRequest &request) const
{
auto task = std::make_shared<std::packaged_task<DeleteReplicationJobOutcome()>>(
[this, request]()
{
return this->deleteReplicationJob(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
SmcClient::DeleteSourceServerOutcome SmcClient::deleteSourceServer(const DeleteSourceServerRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return DeleteSourceServerOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return DeleteSourceServerOutcome(DeleteSourceServerResult(outcome.result()));
else
return DeleteSourceServerOutcome(outcome.error());
}
void SmcClient::deleteSourceServerAsync(const DeleteSourceServerRequest& request, const DeleteSourceServerAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, deleteSourceServer(request), context);
};
asyncExecute(new Runnable(fn));
}
SmcClient::DeleteSourceServerOutcomeCallable SmcClient::deleteSourceServerCallable(const DeleteSourceServerRequest &request) const
{
auto task = std::make_shared<std::packaged_task<DeleteSourceServerOutcome()>>(
[this, request]()
{
return this->deleteSourceServer(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
SmcClient::DescribeReplicationJobsOutcome SmcClient::describeReplicationJobs(const DescribeReplicationJobsRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return DescribeReplicationJobsOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return DescribeReplicationJobsOutcome(DescribeReplicationJobsResult(outcome.result()));
else
return DescribeReplicationJobsOutcome(outcome.error());
}
void SmcClient::describeReplicationJobsAsync(const DescribeReplicationJobsRequest& request, const DescribeReplicationJobsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, describeReplicationJobs(request), context);
};
asyncExecute(new Runnable(fn));
}
SmcClient::DescribeReplicationJobsOutcomeCallable SmcClient::describeReplicationJobsCallable(const DescribeReplicationJobsRequest &request) const
{
auto task = std::make_shared<std::packaged_task<DescribeReplicationJobsOutcome()>>(
[this, request]()
{
return this->describeReplicationJobs(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
SmcClient::DescribeSourceServersOutcome SmcClient::describeSourceServers(const DescribeSourceServersRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return DescribeSourceServersOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return DescribeSourceServersOutcome(DescribeSourceServersResult(outcome.result()));
else
return DescribeSourceServersOutcome(outcome.error());
}
void SmcClient::describeSourceServersAsync(const DescribeSourceServersRequest& request, const DescribeSourceServersAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, describeSourceServers(request), context);
};
asyncExecute(new Runnable(fn));
}
SmcClient::DescribeSourceServersOutcomeCallable SmcClient::describeSourceServersCallable(const DescribeSourceServersRequest &request) const
{
auto task = std::make_shared<std::packaged_task<DescribeSourceServersOutcome()>>(
[this, request]()
{
return this->describeSourceServers(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
SmcClient::ListTagResourcesOutcome SmcClient::listTagResources(const ListTagResourcesRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return ListTagResourcesOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return ListTagResourcesOutcome(ListTagResourcesResult(outcome.result()));
else
return ListTagResourcesOutcome(outcome.error());
}
void SmcClient::listTagResourcesAsync(const ListTagResourcesRequest& request, const ListTagResourcesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, listTagResources(request), context);
};
asyncExecute(new Runnable(fn));
}
SmcClient::ListTagResourcesOutcomeCallable SmcClient::listTagResourcesCallable(const ListTagResourcesRequest &request) const
{
auto task = std::make_shared<std::packaged_task<ListTagResourcesOutcome()>>(
[this, request]()
{
return this->listTagResources(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
SmcClient::ModifyReplicationJobAttributeOutcome SmcClient::modifyReplicationJobAttribute(const ModifyReplicationJobAttributeRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return ModifyReplicationJobAttributeOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return ModifyReplicationJobAttributeOutcome(ModifyReplicationJobAttributeResult(outcome.result()));
else
return ModifyReplicationJobAttributeOutcome(outcome.error());
}
void SmcClient::modifyReplicationJobAttributeAsync(const ModifyReplicationJobAttributeRequest& request, const ModifyReplicationJobAttributeAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, modifyReplicationJobAttribute(request), context);
};
asyncExecute(new Runnable(fn));
}
SmcClient::ModifyReplicationJobAttributeOutcomeCallable SmcClient::modifyReplicationJobAttributeCallable(const ModifyReplicationJobAttributeRequest &request) const
{
auto task = std::make_shared<std::packaged_task<ModifyReplicationJobAttributeOutcome()>>(
[this, request]()
{
return this->modifyReplicationJobAttribute(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
SmcClient::ModifySourceServerAttributeOutcome SmcClient::modifySourceServerAttribute(const ModifySourceServerAttributeRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return ModifySourceServerAttributeOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return ModifySourceServerAttributeOutcome(ModifySourceServerAttributeResult(outcome.result()));
else
return ModifySourceServerAttributeOutcome(outcome.error());
}
void SmcClient::modifySourceServerAttributeAsync(const ModifySourceServerAttributeRequest& request, const ModifySourceServerAttributeAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, modifySourceServerAttribute(request), context);
};
asyncExecute(new Runnable(fn));
}
SmcClient::ModifySourceServerAttributeOutcomeCallable SmcClient::modifySourceServerAttributeCallable(const ModifySourceServerAttributeRequest &request) const
{
auto task = std::make_shared<std::packaged_task<ModifySourceServerAttributeOutcome()>>(
[this, request]()
{
return this->modifySourceServerAttribute(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
SmcClient::StartReplicationJobOutcome SmcClient::startReplicationJob(const StartReplicationJobRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return StartReplicationJobOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return StartReplicationJobOutcome(StartReplicationJobResult(outcome.result()));
else
return StartReplicationJobOutcome(outcome.error());
}
void SmcClient::startReplicationJobAsync(const StartReplicationJobRequest& request, const StartReplicationJobAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, startReplicationJob(request), context);
};
asyncExecute(new Runnable(fn));
}
SmcClient::StartReplicationJobOutcomeCallable SmcClient::startReplicationJobCallable(const StartReplicationJobRequest &request) const
{
auto task = std::make_shared<std::packaged_task<StartReplicationJobOutcome()>>(
[this, request]()
{
return this->startReplicationJob(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
SmcClient::StopReplicationJobOutcome SmcClient::stopReplicationJob(const StopReplicationJobRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return StopReplicationJobOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return StopReplicationJobOutcome(StopReplicationJobResult(outcome.result()));
else
return StopReplicationJobOutcome(outcome.error());
}
void SmcClient::stopReplicationJobAsync(const StopReplicationJobRequest& request, const StopReplicationJobAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, stopReplicationJob(request), context);
};
asyncExecute(new Runnable(fn));
}
SmcClient::StopReplicationJobOutcomeCallable SmcClient::stopReplicationJobCallable(const StopReplicationJobRequest &request) const
{
auto task = std::make_shared<std::packaged_task<StopReplicationJobOutcome()>>(
[this, request]()
{
return this->stopReplicationJob(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
SmcClient::TagResourcesOutcome SmcClient::tagResources(const TagResourcesRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return TagResourcesOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return TagResourcesOutcome(TagResourcesResult(outcome.result()));
else
return TagResourcesOutcome(outcome.error());
}
void SmcClient::tagResourcesAsync(const TagResourcesRequest& request, const TagResourcesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, tagResources(request), context);
};
asyncExecute(new Runnable(fn));
}
SmcClient::TagResourcesOutcomeCallable SmcClient::tagResourcesCallable(const TagResourcesRequest &request) const
{
auto task = std::make_shared<std::packaged_task<TagResourcesOutcome()>>(
[this, request]()
{
return this->tagResources(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
SmcClient::UntagResourcesOutcome SmcClient::untagResources(const UntagResourcesRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return UntagResourcesOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return UntagResourcesOutcome(UntagResourcesResult(outcome.result()));
else
return UntagResourcesOutcome(outcome.error());
}
void SmcClient::untagResourcesAsync(const UntagResourcesRequest& request, const UntagResourcesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, untagResources(request), context);
};
asyncExecute(new Runnable(fn));
}
SmcClient::UntagResourcesOutcomeCallable SmcClient::untagResourcesCallable(const UntagResourcesRequest &request) const
{
auto task = std::make_shared<std::packaged_task<UntagResourcesOutcome()>>(
[this, request]()
{
return this->untagResources(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}

303
smc/src/model/CreateReplicationJobRequest.cc Normal file
View File

@@ -0,0 +1,303 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/smc/model/CreateReplicationJobRequest.h>
using AlibabaCloud::Smc::Model::CreateReplicationJobRequest;
CreateReplicationJobRequest::CreateReplicationJobRequest() :
RpcServiceRequest("smc", "2019-06-01", "CreateReplicationJob")
{
setMethod(HttpRequest::Method::Post);
}
CreateReplicationJobRequest::~CreateReplicationJobRequest()
{}
std::string CreateReplicationJobRequest::getTargetType()const
{
return targetType_;
}
void CreateReplicationJobRequest::setTargetType(const std::string& targetType)
{
targetType_ = targetType;
setCoreParameter("TargetType", targetType);
}
std::string CreateReplicationJobRequest::getClientToken()const
{
return clientToken_;
}
void CreateReplicationJobRequest::setClientToken(const std::string& clientToken)
{
clientToken_ = clientToken;
setCoreParameter("ClientToken", clientToken);
}
std::string CreateReplicationJobRequest::getDescription()const
{
return description_;
}
void CreateReplicationJobRequest::setDescription(const std::string& description)
{
description_ = description;
setCoreParameter("Description", description);
}
std::string CreateReplicationJobRequest::getAccessKeyId()const
{
return accessKeyId_;
}
void CreateReplicationJobRequest::setAccessKeyId(const std::string& accessKeyId)
{
accessKeyId_ = accessKeyId;
setCoreParameter("AccessKeyId", accessKeyId);
}
int CreateReplicationJobRequest::getFrequency()const
{
return frequency_;
}
void CreateReplicationJobRequest::setFrequency(int frequency)
{
frequency_ = frequency;
setCoreParameter("Frequency", std::to_string(frequency));
}
std::string CreateReplicationJobRequest::getReplicationParameters()const
{
return replicationParameters_;
}
void CreateReplicationJobRequest::setReplicationParameters(const std::string& replicationParameters)
{
replicationParameters_ = replicationParameters;
setCoreParameter("ReplicationParameters", replicationParameters);
}
std::string CreateReplicationJobRequest::getRegionId()const
{
return regionId_;
}
void CreateReplicationJobRequest::setRegionId(const std::string& regionId)
{
regionId_ = regionId;
setCoreParameter("RegionId", regionId);
}
std::string CreateReplicationJobRequest::getImageName()const
{
return imageName_;
}
void CreateReplicationJobRequest::setImageName(const std::string& imageName)
{
imageName_ = imageName;
setCoreParameter("ImageName", imageName);
}
int CreateReplicationJobRequest::getSystemDiskSize()const
{
return systemDiskSize_;
}
void CreateReplicationJobRequest::setSystemDiskSize(int systemDiskSize)
{
systemDiskSize_ = systemDiskSize;
setCoreParameter("SystemDiskSize", std::to_string(systemDiskSize));
}
std::string CreateReplicationJobRequest::getInstanceType()const
{
return instanceType_;
}
void CreateReplicationJobRequest::setInstanceType(const std::string& instanceType)
{
instanceType_ = instanceType;
setCoreParameter("InstanceType", instanceType);
}
std::vector<CreateReplicationJobRequest::Tag> CreateReplicationJobRequest::getTag()const
{
return tag_;
}
void CreateReplicationJobRequest::setTag(const std::vector<Tag>& tag)
{
tag_ = tag;
for(int dep1 = 0; dep1!= tag.size(); dep1++) {
auto tagObj = tag.at(dep1);
std::string tagObjStr = "Tag." + std::to_string(dep1);
setCoreParameter(tagObjStr + ".Value", tagObj.value);
setCoreParameter(tagObjStr + ".Key", tagObj.key);
}
}
int CreateReplicationJobRequest::getNetMode()const
{
return netMode_;
}
void CreateReplicationJobRequest::setNetMode(int netMode)
{
netMode_ = netMode;
setCoreParameter("NetMode", std::to_string(netMode));
}
std::string CreateReplicationJobRequest::getSourceId()const
{
return sourceId_;
}
void CreateReplicationJobRequest::setSourceId(const std::string& sourceId)
{
sourceId_ = sourceId;
setCoreParameter("SourceId", sourceId);
}
bool CreateReplicationJobRequest::getRunOnce()const
{
return runOnce_;
}
void CreateReplicationJobRequest::setRunOnce(bool runOnce)
{
runOnce_ = runOnce;
setCoreParameter("RunOnce", runOnce ? "true" : "false");
}
std::string CreateReplicationJobRequest::getResourceOwnerAccount()const
{
return resourceOwnerAccount_;
}
void CreateReplicationJobRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
{
resourceOwnerAccount_ = resourceOwnerAccount;
setCoreParameter("ResourceOwnerAccount", resourceOwnerAccount);
}
std::string CreateReplicationJobRequest::getValidTime()const
{
return validTime_;
}
void CreateReplicationJobRequest::setValidTime(const std::string& validTime)
{
validTime_ = validTime;
setCoreParameter("ValidTime", validTime);
}
long CreateReplicationJobRequest::getOwnerId()const
{
return ownerId_;
}
void CreateReplicationJobRequest::setOwnerId(long ownerId)
{
ownerId_ = ownerId;
setCoreParameter("OwnerId", std::to_string(ownerId));
}
std::vector<CreateReplicationJobRequest::DataDisk> CreateReplicationJobRequest::getDataDisk()const
{
return dataDisk_;
}
void CreateReplicationJobRequest::setDataDisk(const std::vector<DataDisk>& dataDisk)
{
dataDisk_ = dataDisk;
for(int dep1 = 0; dep1!= dataDisk.size(); dep1++) {
auto dataDiskObj = dataDisk.at(dep1);
std::string dataDiskObjStr = "DataDisk." + std::to_string(dep1);
setCoreParameter(dataDiskObjStr + ".Size", std::to_string(dataDiskObj.size));
setCoreParameter(dataDiskObjStr + ".Index", std::to_string(dataDiskObj.index));
}
}
std::string CreateReplicationJobRequest::getVSwitchId()const
{
return vSwitchId_;
}
void CreateReplicationJobRequest::setVSwitchId(const std::string& vSwitchId)
{
vSwitchId_ = vSwitchId;
setCoreParameter("VSwitchId", vSwitchId);
}
std::string CreateReplicationJobRequest::getScheduledStartTime()const
{
return scheduledStartTime_;
}
void CreateReplicationJobRequest::setScheduledStartTime(const std::string& scheduledStartTime)
{
scheduledStartTime_ = scheduledStartTime;
setCoreParameter("ScheduledStartTime", scheduledStartTime);
}
std::string CreateReplicationJobRequest::getInstanceId()const
{
return instanceId_;
}
void CreateReplicationJobRequest::setInstanceId(const std::string& instanceId)
{
instanceId_ = instanceId;
setCoreParameter("InstanceId", instanceId);
}
std::string CreateReplicationJobRequest::getVpcId()const
{
return vpcId_;
}
void CreateReplicationJobRequest::setVpcId(const std::string& vpcId)
{
vpcId_ = vpcId;
setCoreParameter("VpcId", vpcId);
}
std::string CreateReplicationJobRequest::getName()const
{
return name_;
}
void CreateReplicationJobRequest::setName(const std::string& name)
{
name_ = name;
setCoreParameter("Name", name);
}
int CreateReplicationJobRequest::getMaxNumberOfImageToKeep()const
{
return maxNumberOfImageToKeep_;
}
void CreateReplicationJobRequest::setMaxNumberOfImageToKeep(int maxNumberOfImageToKeep)
{
maxNumberOfImageToKeep_ = maxNumberOfImageToKeep;
setCoreParameter("MaxNumberOfImageToKeep", std::to_string(maxNumberOfImageToKeep));
}

51
smc/src/model/CreateReplicationJobResult.cc Normal file
View File

@@ -0,0 +1,51 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/smc/model/CreateReplicationJobResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Smc;
using namespace AlibabaCloud::Smc::Model;
CreateReplicationJobResult::CreateReplicationJobResult() :
ServiceResult()
{}
CreateReplicationJobResult::CreateReplicationJobResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
CreateReplicationJobResult::~CreateReplicationJobResult()
{}
void CreateReplicationJobResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
if(!value["JobId"].isNull())
jobId_ = value["JobId"].asString();
}
std::string CreateReplicationJobResult::getJobId()const
{
return jobId_;
}

73
smc/src/model/DeleteReplicationJobRequest.cc Normal file
View File

@@ -0,0 +1,73 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/smc/model/DeleteReplicationJobRequest.h>
using AlibabaCloud::Smc::Model::DeleteReplicationJobRequest;
DeleteReplicationJobRequest::DeleteReplicationJobRequest() :
RpcServiceRequest("smc", "2019-06-01", "DeleteReplicationJob")
{
setMethod(HttpRequest::Method::Post);
}
DeleteReplicationJobRequest::~DeleteReplicationJobRequest()
{}
std::string DeleteReplicationJobRequest::getResourceOwnerAccount()const
{
return resourceOwnerAccount_;
}
void DeleteReplicationJobRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
{
resourceOwnerAccount_ = resourceOwnerAccount;
setCoreParameter("ResourceOwnerAccount", resourceOwnerAccount);
}
long DeleteReplicationJobRequest::getOwnerId()const
{
return ownerId_;
}
void DeleteReplicationJobRequest::setOwnerId(long ownerId)
{
ownerId_ = ownerId;
setCoreParameter("OwnerId", std::to_string(ownerId));
}
std::string DeleteReplicationJobRequest::getAccessKeyId()const
{
return accessKeyId_;
}
void DeleteReplicationJobRequest::setAccessKeyId(const std::string& accessKeyId)
{
accessKeyId_ = accessKeyId;
setCoreParameter("AccessKeyId", accessKeyId);
}
std::string DeleteReplicationJobRequest::getJobId()const
{
return jobId_;
}
void DeleteReplicationJobRequest::setJobId(const std::string& jobId)
{
jobId_ = jobId;
setCoreParameter("JobId", jobId);
}

44
smc/src/model/DeleteReplicationJobResult.cc Normal file
View File

@@ -0,0 +1,44 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/smc/model/DeleteReplicationJobResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Smc;
using namespace AlibabaCloud::Smc::Model;
DeleteReplicationJobResult::DeleteReplicationJobResult() :
ServiceResult()
{}
DeleteReplicationJobResult::DeleteReplicationJobResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
DeleteReplicationJobResult::~DeleteReplicationJobResult()
{}
void DeleteReplicationJobResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
}

84
smc/src/model/DeleteSourceServerRequest.cc Normal file
View File

@@ -0,0 +1,84 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/smc/model/DeleteSourceServerRequest.h>
using AlibabaCloud::Smc::Model::DeleteSourceServerRequest;
DeleteSourceServerRequest::DeleteSourceServerRequest() :
RpcServiceRequest("smc", "2019-06-01", "DeleteSourceServer")
{
setMethod(HttpRequest::Method::Post);
}
DeleteSourceServerRequest::~DeleteSourceServerRequest()
{}
std::string DeleteSourceServerRequest::getSourceId()const
{
return sourceId_;
}
void DeleteSourceServerRequest::setSourceId(const std::string& sourceId)
{
sourceId_ = sourceId;
setCoreParameter("SourceId", sourceId);
}
std::string DeleteSourceServerRequest::getResourceOwnerAccount()const
{
return resourceOwnerAccount_;
}
void DeleteSourceServerRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
{
resourceOwnerAccount_ = resourceOwnerAccount;
setCoreParameter("ResourceOwnerAccount", resourceOwnerAccount);
}
long DeleteSourceServerRequest::getOwnerId()const
{
return ownerId_;
}
void DeleteSourceServerRequest::setOwnerId(long ownerId)
{
ownerId_ = ownerId;
setCoreParameter("OwnerId", std::to_string(ownerId));
}
std::string DeleteSourceServerRequest::getAccessKeyId()const
{
return accessKeyId_;
}
void DeleteSourceServerRequest::setAccessKeyId(const std::string& accessKeyId)
{
accessKeyId_ = accessKeyId;
setCoreParameter("AccessKeyId", accessKeyId);
}
bool DeleteSourceServerRequest::getForce()const
{
return force_;
}
void DeleteSourceServerRequest::setForce(bool force)
{
force_ = force;
setCoreParameter("Force", force ? "true" : "false");
}

44
smc/src/model/DeleteSourceServerResult.cc Normal file
View File

@@ -0,0 +1,44 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/smc/model/DeleteSourceServerResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Smc;
using namespace AlibabaCloud::Smc::Model;
DeleteSourceServerResult::DeleteSourceServerResult() :
ServiceResult()
{}
DeleteSourceServerResult::DeleteSourceServerResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
DeleteSourceServerResult::~DeleteSourceServerResult()
{}
void DeleteSourceServerResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
}

154
smc/src/model/DescribeReplicationJobsRequest.cc Normal file
View File

@@ -0,0 +1,154 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/smc/model/DescribeReplicationJobsRequest.h>
using AlibabaCloud::Smc::Model::DescribeReplicationJobsRequest;
DescribeReplicationJobsRequest::DescribeReplicationJobsRequest() :
RpcServiceRequest("smc", "2019-06-01", "DescribeReplicationJobs")
{
setMethod(HttpRequest::Method::Post);
}
DescribeReplicationJobsRequest::~DescribeReplicationJobsRequest()
{}
int DescribeReplicationJobsRequest::getPageNumber()const
{
return pageNumber_;
}
void DescribeReplicationJobsRequest::setPageNumber(int pageNumber)
{
pageNumber_ = pageNumber;
setCoreParameter("PageNumber", std::to_string(pageNumber));
}
std::string DescribeReplicationJobsRequest::getAccessKeyId()const
{
return accessKeyId_;
}
void DescribeReplicationJobsRequest::setAccessKeyId(const std::string& accessKeyId)
{
accessKeyId_ = accessKeyId;
setCoreParameter("AccessKeyId", accessKeyId);
}
std::vector<std::string> DescribeReplicationJobsRequest::getJobId()const
{
return jobId_;
}
void DescribeReplicationJobsRequest::setJobId(const std::vector<std::string>& jobId)
{
jobId_ = jobId;
for(int dep1 = 0; dep1!= jobId.size(); dep1++) {
setCoreParameter("JobId."+ std::to_string(dep1), jobId.at(dep1));
}
}
std::string DescribeReplicationJobsRequest::getRegionId()const
{
return regionId_;
}
void DescribeReplicationJobsRequest::setRegionId(const std::string& regionId)
{
regionId_ = regionId;
setCoreParameter("RegionId", regionId);
}
int DescribeReplicationJobsRequest::getPageSize()const
{
return pageSize_;
}
void DescribeReplicationJobsRequest::setPageSize(int pageSize)
{
pageSize_ = pageSize;
setCoreParameter("PageSize", std::to_string(pageSize));
}
std::vector<std::string> DescribeReplicationJobsRequest::getSourceId()const
{
return sourceId_;
}
void DescribeReplicationJobsRequest::setSourceId(const std::vector<std::string>& sourceId)
{
sourceId_ = sourceId;
for(int dep1 = 0; dep1!= sourceId.size(); dep1++) {
setCoreParameter("SourceId."+ std::to_string(dep1), sourceId.at(dep1));
}
}
std::string DescribeReplicationJobsRequest::getBusinessStatus()const
{
return businessStatus_;
}
void DescribeReplicationJobsRequest::setBusinessStatus(const std::string& businessStatus)
{
businessStatus_ = businessStatus;
setCoreParameter("BusinessStatus", businessStatus);
}
std::string DescribeReplicationJobsRequest::getResourceOwnerAccount()const
{
return resourceOwnerAccount_;
}
void DescribeReplicationJobsRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
{
resourceOwnerAccount_ = resourceOwnerAccount;
setCoreParameter("ResourceOwnerAccount", resourceOwnerAccount);
}
long DescribeReplicationJobsRequest::getOwnerId()const
{
return ownerId_;
}
void DescribeReplicationJobsRequest::setOwnerId(long ownerId)
{
ownerId_ = ownerId;
setCoreParameter("OwnerId", std::to_string(ownerId));
}
std::string DescribeReplicationJobsRequest::getName()const
{
return name_;
}
void DescribeReplicationJobsRequest::setName(const std::string& name)
{
name_ = name;
setCoreParameter("Name", name);
}
std::string DescribeReplicationJobsRequest::getStatus()const
{
return status_;
}
void DescribeReplicationJobsRequest::setStatus(const std::string& status)
{
status_ = status;
setCoreParameter("Status", status);
}

158
smc/src/model/DescribeReplicationJobsResult.cc Normal file
View File

@@ -0,0 +1,158 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/smc/model/DescribeReplicationJobsResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Smc;
using namespace AlibabaCloud::Smc::Model;
DescribeReplicationJobsResult::DescribeReplicationJobsResult() :
ServiceResult()
{}
DescribeReplicationJobsResult::DescribeReplicationJobsResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
DescribeReplicationJobsResult::~DescribeReplicationJobsResult()
{}
void DescribeReplicationJobsResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
auto allReplicationJobsNode = value["ReplicationJobs"]["ReplicationJob"];
for (auto valueReplicationJobsReplicationJob : allReplicationJobsNode)
{
ReplicationJob replicationJobsObject;
if(!valueReplicationJobsReplicationJob["JobId"].isNull())
replicationJobsObject.jobId = valueReplicationJobsReplicationJob["JobId"].asString();
if(!valueReplicationJobsReplicationJob["SourceId"].isNull())
replicationJobsObject.sourceId = valueReplicationJobsReplicationJob["SourceId"].asString();
if(!valueReplicationJobsReplicationJob["Name"].isNull())
replicationJobsObject.name = valueReplicationJobsReplicationJob["Name"].asString();
if(!valueReplicationJobsReplicationJob["Description"].isNull())
replicationJobsObject.description = valueReplicationJobsReplicationJob["Description"].asString();
if(!valueReplicationJobsReplicationJob["RegionId"].isNull())
replicationJobsObject.regionId = valueReplicationJobsReplicationJob["RegionId"].asString();
if(!valueReplicationJobsReplicationJob["TargetType"].isNull())
replicationJobsObject.targetType = valueReplicationJobsReplicationJob["TargetType"].asString();
if(!valueReplicationJobsReplicationJob["ScheduledStartTime"].isNull())
replicationJobsObject.scheduledStartTime = valueReplicationJobsReplicationJob["ScheduledStartTime"].asString();
if(!valueReplicationJobsReplicationJob["ImageName"].isNull())
replicationJobsObject.imageName = valueReplicationJobsReplicationJob["ImageName"].asString();
if(!valueReplicationJobsReplicationJob["InstanceId"].isNull())
replicationJobsObject.instanceId = valueReplicationJobsReplicationJob["InstanceId"].asString();
if(!valueReplicationJobsReplicationJob["ImageId"].isNull())
replicationJobsObject.imageId = valueReplicationJobsReplicationJob["ImageId"].asString();
if(!valueReplicationJobsReplicationJob["Status"].isNull())
replicationJobsObject.status = valueReplicationJobsReplicationJob["Status"].asString();
if(!valueReplicationJobsReplicationJob["BusinessStatus"].isNull())
replicationJobsObject.businessStatus = valueReplicationJobsReplicationJob["BusinessStatus"].asString();
if(!valueReplicationJobsReplicationJob["ErrorCode"].isNull())
replicationJobsObject.errorCode = valueReplicationJobsReplicationJob["ErrorCode"].asString();
if(!valueReplicationJobsReplicationJob["Progress"].isNull())
replicationJobsObject.progress = std::stof(valueReplicationJobsReplicationJob["Progress"].asString());
if(!valueReplicationJobsReplicationJob["CreationTime"].isNull())
replicationJobsObject.creationTime = valueReplicationJobsReplicationJob["CreationTime"].asString();
if(!valueReplicationJobsReplicationJob["ValidTime"].isNull())
replicationJobsObject.validTime = valueReplicationJobsReplicationJob["ValidTime"].asString();
if(!valueReplicationJobsReplicationJob["StartTime"].isNull())
replicationJobsObject.startTime = valueReplicationJobsReplicationJob["StartTime"].asString();
if(!valueReplicationJobsReplicationJob["EndTime"].isNull())
replicationJobsObject.endTime = valueReplicationJobsReplicationJob["EndTime"].asString();
if(!valueReplicationJobsReplicationJob["NetMode"].isNull())
replicationJobsObject.netMode = std::stoi(valueReplicationJobsReplicationJob["NetMode"].asString());
if(!valueReplicationJobsReplicationJob["SystemDiskSize"].isNull())
replicationJobsObject.systemDiskSize = std::stoi(valueReplicationJobsReplicationJob["SystemDiskSize"].asString());
if(!valueReplicationJobsReplicationJob["VpcId"].isNull())
replicationJobsObject.vpcId = valueReplicationJobsReplicationJob["VpcId"].asString();
if(!valueReplicationJobsReplicationJob["VSwitchId"].isNull())
replicationJobsObject.vSwitchId = valueReplicationJobsReplicationJob["VSwitchId"].asString();
if(!valueReplicationJobsReplicationJob["TransitionInstanceId"].isNull())
replicationJobsObject.transitionInstanceId = valueReplicationJobsReplicationJob["TransitionInstanceId"].asString();
if(!valueReplicationJobsReplicationJob["StatusInfo"].isNull())
replicationJobsObject.statusInfo = valueReplicationJobsReplicationJob["StatusInfo"].asString();
if(!valueReplicationJobsReplicationJob["ReplicationParameters"].isNull())
replicationJobsObject.replicationParameters = valueReplicationJobsReplicationJob["ReplicationParameters"].asString();
if(!valueReplicationJobsReplicationJob["RunOnce"].isNull())
replicationJobsObject.runOnce = valueReplicationJobsReplicationJob["RunOnce"].asString() == "true";
if(!valueReplicationJobsReplicationJob["Frequency"].isNull())
replicationJobsObject.frequency = std::stoi(valueReplicationJobsReplicationJob["Frequency"].asString());
if(!valueReplicationJobsReplicationJob["MaxNumberOfImageToKeep"].isNull())
replicationJobsObject.maxNumberOfImageToKeep = std::stoi(valueReplicationJobsReplicationJob["MaxNumberOfImageToKeep"].asString());
if(!valueReplicationJobsReplicationJob["InstanceType"].isNull())
replicationJobsObject.instanceType = valueReplicationJobsReplicationJob["InstanceType"].asString();
auto allDataDisksNode = allReplicationJobsNode["DataDisks"]["DataDisk"];
for (auto allReplicationJobsNodeDataDisksDataDisk : allDataDisksNode)
{
ReplicationJob::DataDisk dataDisksObject;
if(!allReplicationJobsNodeDataDisksDataDisk["Size"].isNull())
dataDisksObject.size = std::stoi(allReplicationJobsNodeDataDisksDataDisk["Size"].asString());
if(!allReplicationJobsNodeDataDisksDataDisk["Index"].isNull())
dataDisksObject.index = std::stoi(allReplicationJobsNodeDataDisksDataDisk["Index"].asString());
replicationJobsObject.dataDisks.push_back(dataDisksObject);
}
auto allReplicationJobRunsNode = allReplicationJobsNode["ReplicationJobRuns"]["ReplicationJobRun"];
for (auto allReplicationJobsNodeReplicationJobRunsReplicationJobRun : allReplicationJobRunsNode)
{
ReplicationJob::ReplicationJobRun replicationJobRunsObject;
if(!allReplicationJobsNodeReplicationJobRunsReplicationJobRun["ImageId"].isNull())
replicationJobRunsObject.imageId = allReplicationJobsNodeReplicationJobRunsReplicationJobRun["ImageId"].asString();
if(!allReplicationJobsNodeReplicationJobRunsReplicationJobRun["Type"].isNull())
replicationJobRunsObject.type = allReplicationJobsNodeReplicationJobRunsReplicationJobRun["Type"].asString();
if(!allReplicationJobsNodeReplicationJobRunsReplicationJobRun["StartTime"].isNull())
replicationJobRunsObject.startTime = allReplicationJobsNodeReplicationJobRunsReplicationJobRun["StartTime"].asString();
if(!allReplicationJobsNodeReplicationJobRunsReplicationJobRun["EndTime"].isNull())
replicationJobRunsObject.endTime = allReplicationJobsNodeReplicationJobRunsReplicationJobRun["EndTime"].asString();
replicationJobsObject.replicationJobRuns.push_back(replicationJobRunsObject);
}
replicationJobs_.push_back(replicationJobsObject);
}
if(!value["TotalCount"].isNull())
totalCount_ = std::stoi(value["TotalCount"].asString());
if(!value["PageNumber"].isNull())
pageNumber_ = std::stoi(value["PageNumber"].asString());
if(!value["PageSize"].isNull())
pageSize_ = std::stoi(value["PageSize"].asString());
}
int DescribeReplicationJobsResult::getTotalCount()const
{
return totalCount_;
}
std::vector<DescribeReplicationJobsResult::ReplicationJob> DescribeReplicationJobsResult::getReplicationJobs()const
{
return replicationJobs_;
}
int DescribeReplicationJobsResult::getPageSize()const
{
return pageSize_;
}
int DescribeReplicationJobsResult::getPageNumber()const
{
return pageNumber_;
}

130
smc/src/model/DescribeSourceServersRequest.cc Normal file
View File

@@ -0,0 +1,130 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/smc/model/DescribeSourceServersRequest.h>
using AlibabaCloud::Smc::Model::DescribeSourceServersRequest;
DescribeSourceServersRequest::DescribeSourceServersRequest() :
RpcServiceRequest("smc", "2019-06-01", "DescribeSourceServers")
{
setMethod(HttpRequest::Method::Post);
}
DescribeSourceServersRequest::~DescribeSourceServersRequest()
{}
int DescribeSourceServersRequest::getPageNumber()const
{
return pageNumber_;
}
void DescribeSourceServersRequest::setPageNumber(int pageNumber)
{
pageNumber_ = pageNumber;
setCoreParameter("PageNumber", std::to_string(pageNumber));
}
std::string DescribeSourceServersRequest::getAccessKeyId()const
{
return accessKeyId_;
}
void DescribeSourceServersRequest::setAccessKeyId(const std::string& accessKeyId)
{
accessKeyId_ = accessKeyId;
setCoreParameter("AccessKeyId", accessKeyId);
}
std::string DescribeSourceServersRequest::getJobId()const
{
return jobId_;
}
void DescribeSourceServersRequest::setJobId(const std::string& jobId)
{
jobId_ = jobId;
setCoreParameter("JobId", jobId);
}
int DescribeSourceServersRequest::getPageSize()const
{
return pageSize_;
}
void DescribeSourceServersRequest::setPageSize(int pageSize)
{
pageSize_ = pageSize;
setCoreParameter("PageSize", std::to_string(pageSize));
}
std::string DescribeSourceServersRequest::getState()const
{
return state_;
}
void DescribeSourceServersRequest::setState(const std::string& state)
{
state_ = state;
setCoreParameter("State", state);
}
std::vector<std::string> DescribeSourceServersRequest::getSourceId()const
{
return sourceId_;
}
void DescribeSourceServersRequest::setSourceId(const std::vector<std::string>& sourceId)
{
sourceId_ = sourceId;
for(int dep1 = 0; dep1!= sourceId.size(); dep1++) {
setCoreParameter("SourceId."+ std::to_string(dep1), sourceId.at(dep1));
}
}
std::string DescribeSourceServersRequest::getResourceOwnerAccount()const
{
return resourceOwnerAccount_;
}
void DescribeSourceServersRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
{
resourceOwnerAccount_ = resourceOwnerAccount;
setCoreParameter("ResourceOwnerAccount", resourceOwnerAccount);
}
long DescribeSourceServersRequest::getOwnerId()const
{
return ownerId_;
}
void DescribeSourceServersRequest::setOwnerId(long ownerId)
{
ownerId_ = ownerId;
setCoreParameter("OwnerId", std::to_string(ownerId));
}
std::string DescribeSourceServersRequest::getName()const
{
return name_;
}
void DescribeSourceServersRequest::setName(const std::string& name)
{
name_ = name;
setCoreParameter("Name", name);
}

120
smc/src/model/DescribeSourceServersResult.cc Normal file
View File

@@ -0,0 +1,120 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/smc/model/DescribeSourceServersResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Smc;
using namespace AlibabaCloud::Smc::Model;
DescribeSourceServersResult::DescribeSourceServersResult() :
ServiceResult()
{}
DescribeSourceServersResult::DescribeSourceServersResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
DescribeSourceServersResult::~DescribeSourceServersResult()
{}
void DescribeSourceServersResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
auto allSourceServersNode = value["SourceServers"]["SourceServer"];
for (auto valueSourceServersSourceServer : allSourceServersNode)
{
SourceServer sourceServersObject;
if(!valueSourceServersSourceServer["SourceId"].isNull())
sourceServersObject.sourceId = valueSourceServersSourceServer["SourceId"].asString();
if(!valueSourceServersSourceServer["JobId"].isNull())
sourceServersObject.jobId = valueSourceServersSourceServer["JobId"].asString();
if(!valueSourceServersSourceServer["AgentVersion"].isNull())
sourceServersObject.agentVersion = valueSourceServersSourceServer["AgentVersion"].asString();
if(!valueSourceServersSourceServer["Name"].isNull())
sourceServersObject.name = valueSourceServersSourceServer["Name"].asString();
if(!valueSourceServersSourceServer["Description"].isNull())
sourceServersObject.description = valueSourceServersSourceServer["Description"].asString();
if(!valueSourceServersSourceServer["KernelLevel"].isNull())
sourceServersObject.kernelLevel = std::stoi(valueSourceServersSourceServer["KernelLevel"].asString());
if(!valueSourceServersSourceServer["Platform"].isNull())
sourceServersObject.platform = valueSourceServersSourceServer["Platform"].asString();
if(!valueSourceServersSourceServer["Architecture"].isNull())
sourceServersObject.architecture = valueSourceServersSourceServer["Architecture"].asString();
if(!valueSourceServersSourceServer["SystemDiskSize"].isNull())
sourceServersObject.systemDiskSize = std::stoi(valueSourceServersSourceServer["SystemDiskSize"].asString());
if(!valueSourceServersSourceServer["ReplicationDriver"].isNull())
sourceServersObject.replicationDriver = valueSourceServersSourceServer["ReplicationDriver"].asString();
if(!valueSourceServersSourceServer["SystemInfo"].isNull())
sourceServersObject.systemInfo = valueSourceServersSourceServer["SystemInfo"].asString();
if(!valueSourceServersSourceServer["CreationTime"].isNull())
sourceServersObject.creationTime = valueSourceServersSourceServer["CreationTime"].asString();
if(!valueSourceServersSourceServer["State"].isNull())
sourceServersObject.state = valueSourceServersSourceServer["State"].asString();
if(!valueSourceServersSourceServer["ErrorCode"].isNull())
sourceServersObject.errorCode = valueSourceServersSourceServer["ErrorCode"].asString();
if(!valueSourceServersSourceServer["StatusInfo"].isNull())
sourceServersObject.statusInfo = valueSourceServersSourceServer["StatusInfo"].asString();
if(!valueSourceServersSourceServer["HeartbeatRate"].isNull())
sourceServersObject.heartbeatRate = std::stoi(valueSourceServersSourceServer["HeartbeatRate"].asString());
auto allDataDisksNode = allSourceServersNode["DataDisks"]["DataDisk"];
for (auto allSourceServersNodeDataDisksDataDisk : allDataDisksNode)
{
SourceServer::DataDisk dataDisksObject;
if(!allSourceServersNodeDataDisksDataDisk["Index"].isNull())
dataDisksObject.index = std::stoi(allSourceServersNodeDataDisksDataDisk["Index"].asString());
if(!allSourceServersNodeDataDisksDataDisk["Size"].isNull())
dataDisksObject.size = std::stoi(allSourceServersNodeDataDisksDataDisk["Size"].asString());
if(!allSourceServersNodeDataDisksDataDisk["Path"].isNull())
dataDisksObject.path = allSourceServersNodeDataDisksDataDisk["Path"].asString();
sourceServersObject.dataDisks.push_back(dataDisksObject);
}
sourceServers_.push_back(sourceServersObject);
}
if(!value["TotalCount"].isNull())
totalCount_ = std::stoi(value["TotalCount"].asString());
if(!value["PageNumber"].isNull())
pageNumber_ = std::stoi(value["PageNumber"].asString());
if(!value["PageSize"].isNull())
pageSize_ = std::stoi(value["PageSize"].asString());
}
std::vector<DescribeSourceServersResult::SourceServer> DescribeSourceServersResult::getSourceServers()const
{
return sourceServers_;
}
int DescribeSourceServersResult::getTotalCount()const
{
return totalCount_;
}
int DescribeSourceServersResult::getPageSize()const
{
return pageSize_;
}
int DescribeSourceServersResult::getPageNumber()const
{
return pageNumber_;
}

113
smc/src/model/ListTagResourcesRequest.cc Normal file
View File

@@ -0,0 +1,113 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/smc/model/ListTagResourcesRequest.h>
using AlibabaCloud::Smc::Model::ListTagResourcesRequest;
ListTagResourcesRequest::ListTagResourcesRequest() :
RpcServiceRequest("smc", "2019-06-01", "ListTagResources")
{
setMethod(HttpRequest::Method::Post);
}
ListTagResourcesRequest::~ListTagResourcesRequest()
{}
std::string ListTagResourcesRequest::getAccessKeyId()const
{
return accessKeyId_;
}
void ListTagResourcesRequest::setAccessKeyId(const std::string& accessKeyId)
{
accessKeyId_ = accessKeyId;
setCoreParameter("AccessKeyId", accessKeyId);
}
std::string ListTagResourcesRequest::getNextToken()const
{
return nextToken_;
}
void ListTagResourcesRequest::setNextToken(const std::string& nextToken)
{
nextToken_ = nextToken;
setCoreParameter("NextToken", nextToken);
}
std::vector<ListTagResourcesRequest::Tag> ListTagResourcesRequest::getTag()const
{
return tag_;
}
void ListTagResourcesRequest::setTag(const std::vector<Tag>& tag)
{
tag_ = tag;
for(int dep1 = 0; dep1!= tag.size(); dep1++) {
auto tagObj = tag.at(dep1);
std::string tagObjStr = "Tag." + std::to_string(dep1);
setCoreParameter(tagObjStr + ".Value", tagObj.value);
setCoreParameter(tagObjStr + ".Key", tagObj.key);
}
}
std::vector<std::string> ListTagResourcesRequest::getResourceId()const
{
return resourceId_;
}
void ListTagResourcesRequest::setResourceId(const std::vector<std::string>& resourceId)
{
resourceId_ = resourceId;
for(int dep1 = 0; dep1!= resourceId.size(); dep1++) {
setCoreParameter("ResourceId."+ std::to_string(dep1), resourceId.at(dep1));
}
}
std::string ListTagResourcesRequest::getResourceOwnerAccount()const
{
return resourceOwnerAccount_;
}
void ListTagResourcesRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
{
resourceOwnerAccount_ = resourceOwnerAccount;
setCoreParameter("ResourceOwnerAccount", resourceOwnerAccount);
}
long ListTagResourcesRequest::getOwnerId()const
{
return ownerId_;
}
void ListTagResourcesRequest::setOwnerId(long ownerId)
{
ownerId_ = ownerId;
setCoreParameter("OwnerId", std::to_string(ownerId));
}
std::string ListTagResourcesRequest::getResourceType()const
{
return resourceType_;
}
void ListTagResourcesRequest::setResourceType(const std::string& resourceType)
{
resourceType_ = resourceType;
setCoreParameter("ResourceType", resourceType);
}

70
smc/src/model/ListTagResourcesResult.cc Normal file
View File

@@ -0,0 +1,70 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/smc/model/ListTagResourcesResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Smc;
using namespace AlibabaCloud::Smc::Model;
ListTagResourcesResult::ListTagResourcesResult() :
ServiceResult()
{}
ListTagResourcesResult::ListTagResourcesResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
ListTagResourcesResult::~ListTagResourcesResult()
{}
void ListTagResourcesResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
auto allTagResourcesNode = value["TagResources"]["TagResource"];
for (auto valueTagResourcesTagResource : allTagResourcesNode)
{
TagResource tagResourcesObject;
if(!valueTagResourcesTagResource["ResourceType"].isNull())
tagResourcesObject.resourceType = valueTagResourcesTagResource["ResourceType"].asString();
if(!valueTagResourcesTagResource["ResourceId"].isNull())
tagResourcesObject.resourceId = valueTagResourcesTagResource["ResourceId"].asString();
if(!valueTagResourcesTagResource["TagKey"].isNull())
tagResourcesObject.tagKey = valueTagResourcesTagResource["TagKey"].asString();
if(!valueTagResourcesTagResource["TagValue"].isNull())
tagResourcesObject.tagValue = valueTagResourcesTagResource["TagValue"].asString();
tagResources_.push_back(tagResourcesObject);
}
if(!value["NextToken"].isNull())
nextToken_ = value["NextToken"].asString();
}
std::string ListTagResourcesResult::getNextToken()const
{
return nextToken_;
}
std::vector<ListTagResourcesResult::TagResource> ListTagResourcesResult::getTagResources()const
{
return tagResources_;
}

199
smc/src/model/ModifyReplicationJobAttributeRequest.cc Normal file
View File

@@ -0,0 +1,199 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/smc/model/ModifyReplicationJobAttributeRequest.h>
using AlibabaCloud::Smc::Model::ModifyReplicationJobAttributeRequest;
ModifyReplicationJobAttributeRequest::ModifyReplicationJobAttributeRequest() :
RpcServiceRequest("smc", "2019-06-01", "ModifyReplicationJobAttribute")
{
setMethod(HttpRequest::Method::Post);
}
ModifyReplicationJobAttributeRequest::~ModifyReplicationJobAttributeRequest()
{}
std::string ModifyReplicationJobAttributeRequest::getTargetType()const
{
return targetType_;
}
void ModifyReplicationJobAttributeRequest::setTargetType(const std::string& targetType)
{
targetType_ = targetType;
setCoreParameter("TargetType", targetType);
}
std::string ModifyReplicationJobAttributeRequest::getDescription()const
{
return description_;
}
void ModifyReplicationJobAttributeRequest::setDescription(const std::string& description)
{
description_ = description;
setCoreParameter("Description", description);
}
std::string ModifyReplicationJobAttributeRequest::getAccessKeyId()const
{
return accessKeyId_;
}
void ModifyReplicationJobAttributeRequest::setAccessKeyId(const std::string& accessKeyId)
{
accessKeyId_ = accessKeyId;
setCoreParameter("AccessKeyId", accessKeyId);
}
int ModifyReplicationJobAttributeRequest::getFrequency()const
{
return frequency_;
}
void ModifyReplicationJobAttributeRequest::setFrequency(int frequency)
{
frequency_ = frequency;
setCoreParameter("Frequency", std::to_string(frequency));
}
std::string ModifyReplicationJobAttributeRequest::getJobId()const
{
return jobId_;
}
void ModifyReplicationJobAttributeRequest::setJobId(const std::string& jobId)
{
jobId_ = jobId;
setCoreParameter("JobId", jobId);
}
std::string ModifyReplicationJobAttributeRequest::getImageName()const
{
return imageName_;
}
void ModifyReplicationJobAttributeRequest::setImageName(const std::string& imageName)
{
imageName_ = imageName;
setCoreParameter("ImageName", imageName);
}
int ModifyReplicationJobAttributeRequest::getSystemDiskSize()const
{
return systemDiskSize_;
}
void ModifyReplicationJobAttributeRequest::setSystemDiskSize(int systemDiskSize)
{
systemDiskSize_ = systemDiskSize;
setCoreParameter("SystemDiskSize", std::to_string(systemDiskSize));
}
std::string ModifyReplicationJobAttributeRequest::getInstanceType()const
{
return instanceType_;
}
void ModifyReplicationJobAttributeRequest::setInstanceType(const std::string& instanceType)
{
instanceType_ = instanceType;
setCoreParameter("InstanceType", instanceType);
}
std::string ModifyReplicationJobAttributeRequest::getResourceOwnerAccount()const
{
return resourceOwnerAccount_;
}
void ModifyReplicationJobAttributeRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
{
resourceOwnerAccount_ = resourceOwnerAccount;
setCoreParameter("ResourceOwnerAccount", resourceOwnerAccount);
}
long ModifyReplicationJobAttributeRequest::getOwnerId()const
{
return ownerId_;
}
void ModifyReplicationJobAttributeRequest::setOwnerId(long ownerId)
{
ownerId_ = ownerId;
setCoreParameter("OwnerId", std::to_string(ownerId));
}
std::vector<ModifyReplicationJobAttributeRequest::DataDisk> ModifyReplicationJobAttributeRequest::getDataDisk()const
{
return dataDisk_;
}
void ModifyReplicationJobAttributeRequest::setDataDisk(const std::vector<DataDisk>& dataDisk)
{
dataDisk_ = dataDisk;
for(int dep1 = 0; dep1!= dataDisk.size(); dep1++) {
auto dataDiskObj = dataDisk.at(dep1);
std::string dataDiskObjStr = "DataDisk." + std::to_string(dep1);
setCoreParameter(dataDiskObjStr + ".Size", std::to_string(dataDiskObj.size));
setCoreParameter(dataDiskObjStr + ".Index", std::to_string(dataDiskObj.index));
}
}
std::string ModifyReplicationJobAttributeRequest::getScheduledStartTime()const
{
return scheduledStartTime_;
}
void ModifyReplicationJobAttributeRequest::setScheduledStartTime(const std::string& scheduledStartTime)
{
scheduledStartTime_ = scheduledStartTime;
setCoreParameter("ScheduledStartTime", scheduledStartTime);
}
std::string ModifyReplicationJobAttributeRequest::getInstanceId()const
{
return instanceId_;
}
void ModifyReplicationJobAttributeRequest::setInstanceId(const std::string& instanceId)
{
instanceId_ = instanceId;
setCoreParameter("InstanceId", instanceId);
}
std::string ModifyReplicationJobAttributeRequest::getName()const
{
return name_;
}
void ModifyReplicationJobAttributeRequest::setName(const std::string& name)
{
name_ = name;
setCoreParameter("Name", name);
}
int ModifyReplicationJobAttributeRequest::getMaxNumberOfImageToKeep()const
{
return maxNumberOfImageToKeep_;
}
void ModifyReplicationJobAttributeRequest::setMaxNumberOfImageToKeep(int maxNumberOfImageToKeep)
{
maxNumberOfImageToKeep_ = maxNumberOfImageToKeep;
setCoreParameter("MaxNumberOfImageToKeep", std::to_string(maxNumberOfImageToKeep));
}

44
smc/src/model/ModifyReplicationJobAttributeResult.cc Normal file
View File

@@ -0,0 +1,44 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/smc/model/ModifyReplicationJobAttributeResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Smc;
using namespace AlibabaCloud::Smc::Model;
ModifyReplicationJobAttributeResult::ModifyReplicationJobAttributeResult() :
ServiceResult()
{}
ModifyReplicationJobAttributeResult::ModifyReplicationJobAttributeResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
ModifyReplicationJobAttributeResult::~ModifyReplicationJobAttributeResult()
{}
void ModifyReplicationJobAttributeResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
}

95
smc/src/model/ModifySourceServerAttributeRequest.cc Normal file
View File

@@ -0,0 +1,95 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/smc/model/ModifySourceServerAttributeRequest.h>
using AlibabaCloud::Smc::Model::ModifySourceServerAttributeRequest;
ModifySourceServerAttributeRequest::ModifySourceServerAttributeRequest() :
RpcServiceRequest("smc", "2019-06-01", "ModifySourceServerAttribute")
{
setMethod(HttpRequest::Method::Post);
}
ModifySourceServerAttributeRequest::~ModifySourceServerAttributeRequest()
{}
std::string ModifySourceServerAttributeRequest::getDescription()const
{
return description_;
}
void ModifySourceServerAttributeRequest::setDescription(const std::string& description)
{
description_ = description;
setCoreParameter("Description", description);
}
std::string ModifySourceServerAttributeRequest::getAccessKeyId()const
{
return accessKeyId_;
}
void ModifySourceServerAttributeRequest::setAccessKeyId(const std::string& accessKeyId)
{
accessKeyId_ = accessKeyId;
setCoreParameter("AccessKeyId", accessKeyId);
}
std::string ModifySourceServerAttributeRequest::getSourceId()const
{
return sourceId_;
}
void ModifySourceServerAttributeRequest::setSourceId(const std::string& sourceId)
{
sourceId_ = sourceId;
setCoreParameter("SourceId", sourceId);
}
std::string ModifySourceServerAttributeRequest::getResourceOwnerAccount()const
{
return resourceOwnerAccount_;
}
void ModifySourceServerAttributeRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
{
resourceOwnerAccount_ = resourceOwnerAccount;
setCoreParameter("ResourceOwnerAccount", resourceOwnerAccount);
}
long ModifySourceServerAttributeRequest::getOwnerId()const
{
return ownerId_;
}
void ModifySourceServerAttributeRequest::setOwnerId(long ownerId)
{
ownerId_ = ownerId;
setCoreParameter("OwnerId", std::to_string(ownerId));
}
std::string ModifySourceServerAttributeRequest::getName()const
{
return name_;
}
void ModifySourceServerAttributeRequest::setName(const std::string& name)
{
name_ = name;
setCoreParameter("Name", name);
}

44
smc/src/model/ModifySourceServerAttributeResult.cc Normal file
View File

@@ -0,0 +1,44 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/smc/model/ModifySourceServerAttributeResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Smc;
using namespace AlibabaCloud::Smc::Model;
ModifySourceServerAttributeResult::ModifySourceServerAttributeResult() :
ServiceResult()
{}
ModifySourceServerAttributeResult::ModifySourceServerAttributeResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
ModifySourceServerAttributeResult::~ModifySourceServerAttributeResult()
{}
void ModifySourceServerAttributeResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
}

73
smc/src/model/StartReplicationJobRequest.cc Normal file
View File

@@ -0,0 +1,73 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/smc/model/StartReplicationJobRequest.h>
using AlibabaCloud::Smc::Model::StartReplicationJobRequest;
StartReplicationJobRequest::StartReplicationJobRequest() :
RpcServiceRequest("smc", "2019-06-01", "StartReplicationJob")
{
setMethod(HttpRequest::Method::Post);
}
StartReplicationJobRequest::~StartReplicationJobRequest()
{}
std::string StartReplicationJobRequest::getResourceOwnerAccount()const
{
return resourceOwnerAccount_;
}
void StartReplicationJobRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
{
resourceOwnerAccount_ = resourceOwnerAccount;
setCoreParameter("ResourceOwnerAccount", resourceOwnerAccount);
}
long StartReplicationJobRequest::getOwnerId()const
{
return ownerId_;
}
void StartReplicationJobRequest::setOwnerId(long ownerId)
{
ownerId_ = ownerId;
setCoreParameter("OwnerId", std::to_string(ownerId));
}
std::string StartReplicationJobRequest::getAccessKeyId()const
{
return accessKeyId_;
}
void StartReplicationJobRequest::setAccessKeyId(const std::string& accessKeyId)
{
accessKeyId_ = accessKeyId;
setCoreParameter("AccessKeyId", accessKeyId);
}
std::string StartReplicationJobRequest::getJobId()const
{
return jobId_;
}
void StartReplicationJobRequest::setJobId(const std::string& jobId)
{
jobId_ = jobId;
setCoreParameter("JobId", jobId);
}

44
smc/src/model/StartReplicationJobResult.cc Normal file
View File

@@ -0,0 +1,44 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/smc/model/StartReplicationJobResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Smc;
using namespace AlibabaCloud::Smc::Model;
StartReplicationJobResult::StartReplicationJobResult() :
ServiceResult()
{}
StartReplicationJobResult::StartReplicationJobResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
StartReplicationJobResult::~StartReplicationJobResult()
{}
void StartReplicationJobResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
}

73
smc/src/model/StopReplicationJobRequest.cc Normal file
View File

@@ -0,0 +1,73 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/smc/model/StopReplicationJobRequest.h>
using AlibabaCloud::Smc::Model::StopReplicationJobRequest;
StopReplicationJobRequest::StopReplicationJobRequest() :
RpcServiceRequest("smc", "2019-06-01", "StopReplicationJob")
{
setMethod(HttpRequest::Method::Post);
}
StopReplicationJobRequest::~StopReplicationJobRequest()
{}
std::string StopReplicationJobRequest::getResourceOwnerAccount()const
{
return resourceOwnerAccount_;
}
void StopReplicationJobRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
{
resourceOwnerAccount_ = resourceOwnerAccount;
setCoreParameter("ResourceOwnerAccount", resourceOwnerAccount);
}
long StopReplicationJobRequest::getOwnerId()const
{
return ownerId_;
}
void StopReplicationJobRequest::setOwnerId(long ownerId)
{
ownerId_ = ownerId;
setCoreParameter("OwnerId", std::to_string(ownerId));
}
std::string StopReplicationJobRequest::getAccessKeyId()const
{
return accessKeyId_;
}
void StopReplicationJobRequest::setAccessKeyId(const std::string& accessKeyId)
{
accessKeyId_ = accessKeyId;
setCoreParameter("AccessKeyId", accessKeyId);
}
std::string StopReplicationJobRequest::getJobId()const
{
return jobId_;
}
void StopReplicationJobRequest::setJobId(const std::string& jobId)
{
jobId_ = jobId;
setCoreParameter("JobId", jobId);
}

44
smc/src/model/StopReplicationJobResult.cc Normal file
View File

@@ -0,0 +1,44 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/smc/model/StopReplicationJobResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Smc;
using namespace AlibabaCloud::Smc::Model;
StopReplicationJobResult::StopReplicationJobResult() :
ServiceResult()
{}
StopReplicationJobResult::StopReplicationJobResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
StopReplicationJobResult::~StopReplicationJobResult()
{}
void StopReplicationJobResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
}

102
smc/src/model/TagResourcesRequest.cc Normal file
View File

@@ -0,0 +1,102 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/smc/model/TagResourcesRequest.h>
using AlibabaCloud::Smc::Model::TagResourcesRequest;
TagResourcesRequest::TagResourcesRequest() :
RpcServiceRequest("smc", "2019-06-01", "TagResources")
{
setMethod(HttpRequest::Method::Post);
}
TagResourcesRequest::~TagResourcesRequest()
{}
std::string TagResourcesRequest::getAccessKeyId()const
{
return accessKeyId_;
}
void TagResourcesRequest::setAccessKeyId(const std::string& accessKeyId)
{
accessKeyId_ = accessKeyId;
setCoreParameter("AccessKeyId", accessKeyId);
}
std::vector<TagResourcesRequest::Tag> TagResourcesRequest::getTag()const
{
return tag_;
}
void TagResourcesRequest::setTag(const std::vector<Tag>& tag)
{
tag_ = tag;
for(int dep1 = 0; dep1!= tag.size(); dep1++) {
auto tagObj = tag.at(dep1);
std::string tagObjStr = "Tag." + std::to_string(dep1);
setCoreParameter(tagObjStr + ".Value", tagObj.value);
setCoreParameter(tagObjStr + ".Key", tagObj.key);
}
}
std::vector<std::string> TagResourcesRequest::getResourceId()const
{
return resourceId_;
}
void TagResourcesRequest::setResourceId(const std::vector<std::string>& resourceId)
{
resourceId_ = resourceId;
for(int dep1 = 0; dep1!= resourceId.size(); dep1++) {
setCoreParameter("ResourceId."+ std::to_string(dep1), resourceId.at(dep1));
}
}
std::string TagResourcesRequest::getResourceOwnerAccount()const
{
return resourceOwnerAccount_;
}
void TagResourcesRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
{
resourceOwnerAccount_ = resourceOwnerAccount;
setCoreParameter("ResourceOwnerAccount", resourceOwnerAccount);
}
long TagResourcesRequest::getOwnerId()const
{
return ownerId_;
}
void TagResourcesRequest::setOwnerId(long ownerId)
{
ownerId_ = ownerId;
setCoreParameter("OwnerId", std::to_string(ownerId));
}
std::string TagResourcesRequest::getResourceType()const
{
return resourceType_;
}
void TagResourcesRequest::setResourceType(const std::string& resourceType)
{
resourceType_ = resourceType;
setCoreParameter("ResourceType", resourceType);
}

44
smc/src/model/TagResourcesResult.cc Normal file
View File

@@ -0,0 +1,44 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/smc/model/TagResourcesResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Smc;
using namespace AlibabaCloud::Smc::Model;
TagResourcesResult::TagResourcesResult() :
ServiceResult()
{}
TagResourcesResult::TagResourcesResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
TagResourcesResult::~TagResourcesResult()
{}
void TagResourcesResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
}

110
smc/src/model/UntagResourcesRequest.cc Normal file
View File

@@ -0,0 +1,110 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/smc/model/UntagResourcesRequest.h>
using AlibabaCloud::Smc::Model::UntagResourcesRequest;
UntagResourcesRequest::UntagResourcesRequest() :
RpcServiceRequest("smc", "2019-06-01", "UntagResources")
{
setMethod(HttpRequest::Method::Post);
}
UntagResourcesRequest::~UntagResourcesRequest()
{}
std::string UntagResourcesRequest::getAccessKeyId()const
{
return accessKeyId_;
}
void UntagResourcesRequest::setAccessKeyId(const std::string& accessKeyId)
{
accessKeyId_ = accessKeyId;
setCoreParameter("AccessKeyId", accessKeyId);
}
bool UntagResourcesRequest::getAll()const
{
return all_;
}
void UntagResourcesRequest::setAll(bool all)
{
all_ = all;
setCoreParameter("All", all ? "true" : "false");
}
std::vector<std::string> UntagResourcesRequest::getResourceId()const
{
return resourceId_;
}
void UntagResourcesRequest::setResourceId(const std::vector<std::string>& resourceId)
{
resourceId_ = resourceId;
for(int dep1 = 0; dep1!= resourceId.size(); dep1++) {
setCoreParameter("ResourceId."+ std::to_string(dep1), resourceId.at(dep1));
}
}
std::string UntagResourcesRequest::getResourceOwnerAccount()const
{
return resourceOwnerAccount_;
}
void UntagResourcesRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
{
resourceOwnerAccount_ = resourceOwnerAccount;
setCoreParameter("ResourceOwnerAccount", resourceOwnerAccount);
}
long UntagResourcesRequest::getOwnerId()const
{
return ownerId_;
}
void UntagResourcesRequest::setOwnerId(long ownerId)
{
ownerId_ = ownerId;
setCoreParameter("OwnerId", std::to_string(ownerId));
}
std::string UntagResourcesRequest::getResourceType()const
{
return resourceType_;
}
void UntagResourcesRequest::setResourceType(const std::string& resourceType)
{
resourceType_ = resourceType;
setCoreParameter("ResourceType", resourceType);
}
std::vector<std::string> UntagResourcesRequest::getTagKey()const
{
return tagKey_;
}
void UntagResourcesRequest::setTagKey(const std::vector<std::string>& tagKey)
{
tagKey_ = tagKey;
for(int dep1 = 0; dep1!= tagKey.size(); dep1++) {
setCoreParameter("TagKey."+ std::to_string(dep1), tagKey.at(dep1));
}
}

44
smc/src/model/UntagResourcesResult.cc Normal file
View File

@@ -0,0 +1,44 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/smc/model/UntagResourcesResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Smc;
using namespace AlibabaCloud::Smc::Model;
UntagResourcesResult::UntagResourcesResult() :
ServiceResult()
{}
UntagResourcesResult::UntagResourcesResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
UntagResourcesResult::~UntagResourcesResult()
{}
void UntagResourcesResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
}