Add spotDuration support.

2020-09-23 09:45:22 +00:00
parent 9290117d12
commit f014392806
62 changed files with 2761 additions and 8 deletions
--- a/ecs/src/EcsClient.cc
+++ b/ecs/src/EcsClient.cc
@@ -1167,6 +1167,42 @@ EcsClient::CreateCommandOutcomeCallable EcsClient::createCommandCallable(const C
 	return task->get_future();
 }

+EcsClient::CreateDedicatedHostClusterOutcome EcsClient::createDedicatedHostCluster(const CreateDedicatedHostClusterRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return CreateDedicatedHostClusterOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return CreateDedicatedHostClusterOutcome(CreateDedicatedHostClusterResult(outcome.result()));
+	else
+		return CreateDedicatedHostClusterOutcome(outcome.error());
+}
+
+void EcsClient::createDedicatedHostClusterAsync(const CreateDedicatedHostClusterRequest& request, const CreateDedicatedHostClusterAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, createDedicatedHostCluster(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+EcsClient::CreateDedicatedHostClusterOutcomeCallable EcsClient::createDedicatedHostClusterCallable(const CreateDedicatedHostClusterRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<CreateDedicatedHostClusterOutcome()>>(
+			[this, request]()
+			{
+			return this->createDedicatedHostCluster(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 EcsClient::CreateDemandOutcome EcsClient::createDemand(const CreateDemandRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -2211,6 +2247,42 @@ EcsClient::DeleteCommandOutcomeCallable EcsClient::deleteCommandCallable(const D
 	return task->get_future();
 }

+EcsClient::DeleteDedicatedHostClusterOutcome EcsClient::deleteDedicatedHostCluster(const DeleteDedicatedHostClusterRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DeleteDedicatedHostClusterOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DeleteDedicatedHostClusterOutcome(DeleteDedicatedHostClusterResult(outcome.result()));
+	else
+		return DeleteDedicatedHostClusterOutcome(outcome.error());
+}
+
+void EcsClient::deleteDedicatedHostClusterAsync(const DeleteDedicatedHostClusterRequest& request, const DeleteDedicatedHostClusterAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, deleteDedicatedHostCluster(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+EcsClient::DeleteDedicatedHostClusterOutcomeCallable EcsClient::deleteDedicatedHostClusterCallable(const DeleteDedicatedHostClusterRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DeleteDedicatedHostClusterOutcome()>>(
+			[this, request]()
+			{
+			return this->deleteDedicatedHostCluster(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 EcsClient::DeleteDemandOutcome EcsClient::deleteDemand(const DeleteDemandRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -3579,6 +3651,42 @@ EcsClient::DescribeDedicatedHostAutoRenewOutcomeCallable EcsClient::describeDedi
 	return task->get_future();
 }

+EcsClient::DescribeDedicatedHostClustersOutcome EcsClient::describeDedicatedHostClusters(const DescribeDedicatedHostClustersRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DescribeDedicatedHostClustersOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DescribeDedicatedHostClustersOutcome(DescribeDedicatedHostClustersResult(outcome.result()));
+	else
+		return DescribeDedicatedHostClustersOutcome(outcome.error());
+}
+
+void EcsClient::describeDedicatedHostClustersAsync(const DescribeDedicatedHostClustersRequest& request, const DescribeDedicatedHostClustersAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, describeDedicatedHostClusters(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+EcsClient::DescribeDedicatedHostClustersOutcomeCallable EcsClient::describeDedicatedHostClustersCallable(const DescribeDedicatedHostClustersRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DescribeDedicatedHostClustersOutcome()>>(
+			[this, request]()
+			{
+			return this->describeDedicatedHostClusters(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 EcsClient::DescribeDedicatedHostTypesOutcome EcsClient::describeDedicatedHostTypes(const DescribeDedicatedHostTypesRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -5595,6 +5703,42 @@ EcsClient::DescribeSecurityGroupsOutcomeCallable EcsClient::describeSecurityGrou
 	return task->get_future();
 }

+EcsClient::DescribeSendFileResultsOutcome EcsClient::describeSendFileResults(const DescribeSendFileResultsRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DescribeSendFileResultsOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DescribeSendFileResultsOutcome(DescribeSendFileResultsResult(outcome.result()));
+	else
+		return DescribeSendFileResultsOutcome(outcome.error());
+}
+
+void EcsClient::describeSendFileResultsAsync(const DescribeSendFileResultsRequest& request, const DescribeSendFileResultsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, describeSendFileResults(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+EcsClient::DescribeSendFileResultsOutcomeCallable EcsClient::describeSendFileResultsCallable(const DescribeSendFileResultsRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DescribeSendFileResultsOutcome()>>(
+			[this, request]()
+			{
+			return this->describeSendFileResults(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 EcsClient::DescribeSnapshotLinksOutcome EcsClient::describeSnapshotLinks(const DescribeSnapshotLinksRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -7395,6 +7539,42 @@ EcsClient::ModifyDedicatedHostAutoRenewAttributeOutcomeCallable EcsClient::modif
 	return task->get_future();
 }

+EcsClient::ModifyDedicatedHostClusterAttributeOutcome EcsClient::modifyDedicatedHostClusterAttribute(const ModifyDedicatedHostClusterAttributeRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return ModifyDedicatedHostClusterAttributeOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return ModifyDedicatedHostClusterAttributeOutcome(ModifyDedicatedHostClusterAttributeResult(outcome.result()));
+	else
+		return ModifyDedicatedHostClusterAttributeOutcome(outcome.error());
+}
+
+void EcsClient::modifyDedicatedHostClusterAttributeAsync(const ModifyDedicatedHostClusterAttributeRequest& request, const ModifyDedicatedHostClusterAttributeAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, modifyDedicatedHostClusterAttribute(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+EcsClient::ModifyDedicatedHostClusterAttributeOutcomeCallable EcsClient::modifyDedicatedHostClusterAttributeCallable(const ModifyDedicatedHostClusterAttributeRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<ModifyDedicatedHostClusterAttributeOutcome()>>(
+			[this, request]()
+			{
+			return this->modifyDedicatedHostClusterAttribute(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 EcsClient::ModifyDedicatedHostsChargeTypeOutcome EcsClient::modifyDedicatedHostsChargeType(const ModifyDedicatedHostsChargeTypeRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -9843,6 +10023,42 @@ EcsClient::RunInstancesOutcomeCallable EcsClient::runInstancesCallable(const Run
 	return task->get_future();
 }

+EcsClient::SendFileOutcome EcsClient::sendFile(const SendFileRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return SendFileOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return SendFileOutcome(SendFileResult(outcome.result()));
+	else
+		return SendFileOutcome(outcome.error());
+}
+
+void EcsClient::sendFileAsync(const SendFileRequest& request, const SendFileAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, sendFile(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+EcsClient::SendFileOutcomeCallable EcsClient::sendFileCallable(const SendFileRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<SendFileOutcome()>>(
+			[this, request]()
+			{
+			return this->sendFile(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 EcsClient::StartInstanceOutcome EcsClient::startInstance(const StartInstanceRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
--- a/ecs/src/model/AllocateDedicatedHostsRequest.cc
+++ b/ecs/src/model/AllocateDedicatedHostsRequest.cc
@@ -60,6 +60,17 @@ void AllocateDedicatedHostsRequest::setDescription(const std::string& descriptio
 	setParameter("Description", description);
 }

+float AllocateDedicatedHostsRequest::getCpuOverCommitRatio()const
+{
+	return cpuOverCommitRatio_;
+}
+
+void AllocateDedicatedHostsRequest::setCpuOverCommitRatio(float cpuOverCommitRatio)
+{
+	cpuOverCommitRatio_ = cpuOverCommitRatio;
+	setParameter("CpuOverCommitRatio", std::to_string(cpuOverCommitRatio));
+}
+
 std::string AllocateDedicatedHostsRequest::getResourceGroupId()const
 {
 	return resourceGroupId_;
@@ -93,6 +104,17 @@ void AllocateDedicatedHostsRequest::setActionOnMaintenance(const std::string& ac
 	setParameter("ActionOnMaintenance", actionOnMaintenance);
 }

+std::string AllocateDedicatedHostsRequest::getDedicatedHostClusterId()const
+{
+	return dedicatedHostClusterId_;
+}
+
+void AllocateDedicatedHostsRequest::setDedicatedHostClusterId(const std::string& dedicatedHostClusterId)
+{
+	dedicatedHostClusterId_ = dedicatedHostClusterId;
+	setParameter("DedicatedHostClusterId", dedicatedHostClusterId);
+}
+
 std::vector<AllocateDedicatedHostsRequest::Tag> AllocateDedicatedHostsRequest::getTag()const
 {
 	return tag_;
--- a/ecs/src/model/AttachNetworkInterfaceRequest.cc
+++ b/ecs/src/model/AttachNetworkInterfaceRequest.cc
@@ -82,6 +82,17 @@ void AttachNetworkInterfaceRequest::setOwnerAccount(const std::string& ownerAcco
 	setParameter("OwnerAccount", ownerAccount);
 }

+bool AttachNetworkInterfaceRequest::getWaitForNetworkConfigurationReady()const
+{
+	return waitForNetworkConfigurationReady_;
+}
+
+void AttachNetworkInterfaceRequest::setWaitForNetworkConfigurationReady(bool waitForNetworkConfigurationReady)
+{
+	waitForNetworkConfigurationReady_ = waitForNetworkConfigurationReady;
+	setParameter("WaitForNetworkConfigurationReady", waitForNetworkConfigurationReady ? "true" : "false");
+}
+
 long AttachNetworkInterfaceRequest::getOwnerId()const
 {
 	return ownerId_;
--- a/ecs/src/model/CreateDedicatedHostClusterRequest.cc
+++ b/ecs/src/model/CreateDedicatedHostClusterRequest.cc
@@ -0,0 +1,155 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/ecs/model/CreateDedicatedHostClusterRequest.h>
+
+using AlibabaCloud::Ecs::Model::CreateDedicatedHostClusterRequest;
+
+CreateDedicatedHostClusterRequest::CreateDedicatedHostClusterRequest() :
+	RpcServiceRequest("ecs", "2014-05-26", "CreateDedicatedHostCluster")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+CreateDedicatedHostClusterRequest::~CreateDedicatedHostClusterRequest()
+{}
+
+std::string CreateDedicatedHostClusterRequest::getDedicatedHostClusterName()const
+{
+	return dedicatedHostClusterName_;
+}
+
+void CreateDedicatedHostClusterRequest::setDedicatedHostClusterName(const std::string& dedicatedHostClusterName)
+{
+	dedicatedHostClusterName_ = dedicatedHostClusterName;
+	setParameter("DedicatedHostClusterName", dedicatedHostClusterName);
+}
+
+long CreateDedicatedHostClusterRequest::getResourceOwnerId()const
+{
+	return resourceOwnerId_;
+}
+
+void CreateDedicatedHostClusterRequest::setResourceOwnerId(long resourceOwnerId)
+{
+	resourceOwnerId_ = resourceOwnerId;
+	setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
+}
+
+std::string CreateDedicatedHostClusterRequest::getDescription()const
+{
+	return description_;
+}
+
+void CreateDedicatedHostClusterRequest::setDescription(const std::string& description)
+{
+	description_ = description;
+	setParameter("Description", description);
+}
+
+std::string CreateDedicatedHostClusterRequest::getResourceGroupId()const
+{
+	return resourceGroupId_;
+}
+
+void CreateDedicatedHostClusterRequest::setResourceGroupId(const std::string& resourceGroupId)
+{
+	resourceGroupId_ = resourceGroupId;
+	setParameter("ResourceGroupId", resourceGroupId);
+}
+
+std::string CreateDedicatedHostClusterRequest::getRegionId()const
+{
+	return regionId_;
+}
+
+void CreateDedicatedHostClusterRequest::setRegionId(const std::string& regionId)
+{
+	regionId_ = regionId;
+	setParameter("RegionId", regionId);
+}
+
+std::vector<CreateDedicatedHostClusterRequest::Tag> CreateDedicatedHostClusterRequest::getTag()const
+{
+	return tag_;
+}
+
+void CreateDedicatedHostClusterRequest::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 + 1);
+		setParameter(tagObjStr + ".Key", tagObj.key);
+		setParameter(tagObjStr + ".Value", tagObj.value);
+	}
+}
+
+bool CreateDedicatedHostClusterRequest::getDryRun()const
+{
+	return dryRun_;
+}
+
+void CreateDedicatedHostClusterRequest::setDryRun(bool dryRun)
+{
+	dryRun_ = dryRun;
+	setParameter("DryRun", dryRun ? "true" : "false");
+}
+
+std::string CreateDedicatedHostClusterRequest::getResourceOwnerAccount()const
+{
+	return resourceOwnerAccount_;
+}
+
+void CreateDedicatedHostClusterRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
+{
+	resourceOwnerAccount_ = resourceOwnerAccount;
+	setParameter("ResourceOwnerAccount", resourceOwnerAccount);
+}
+
+std::string CreateDedicatedHostClusterRequest::getOwnerAccount()const
+{
+	return ownerAccount_;
+}
+
+void CreateDedicatedHostClusterRequest::setOwnerAccount(const std::string& ownerAccount)
+{
+	ownerAccount_ = ownerAccount;
+	setParameter("OwnerAccount", ownerAccount);
+}
+
+long CreateDedicatedHostClusterRequest::getOwnerId()const
+{
+	return ownerId_;
+}
+
+void CreateDedicatedHostClusterRequest::setOwnerId(long ownerId)
+{
+	ownerId_ = ownerId;
+	setParameter("OwnerId", std::to_string(ownerId));
+}
+
+std::string CreateDedicatedHostClusterRequest::getZoneId()const
+{
+	return zoneId_;
+}
+
+void CreateDedicatedHostClusterRequest::setZoneId(const std::string& zoneId)
+{
+	zoneId_ = zoneId;
+	setParameter("ZoneId", zoneId);
+}
+
--- a/ecs/src/model/CreateDedicatedHostClusterResult.cc
+++ b/ecs/src/model/CreateDedicatedHostClusterResult.cc
@@ -0,0 +1,51 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/ecs/model/CreateDedicatedHostClusterResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Ecs;
+using namespace AlibabaCloud::Ecs::Model;
+
+CreateDedicatedHostClusterResult::CreateDedicatedHostClusterResult() :
+	ServiceResult()
+{}
+
+CreateDedicatedHostClusterResult::CreateDedicatedHostClusterResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+CreateDedicatedHostClusterResult::~CreateDedicatedHostClusterResult()
+{}
+
+void CreateDedicatedHostClusterResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	if(!value["DedicatedHostClusterId"].isNull())
+		dedicatedHostClusterId_ = value["DedicatedHostClusterId"].asString();
+
+}
+
+std::string CreateDedicatedHostClusterResult::getDedicatedHostClusterId()const
+{
+	return dedicatedHostClusterId_;
+}
+
--- a/ecs/src/model/CreateNetworkInterfaceRequest.cc
+++ b/ecs/src/model/CreateNetworkInterfaceRequest.cc
@@ -27,6 +27,17 @@ CreateNetworkInterfaceRequest::CreateNetworkInterfaceRequest() :
 CreateNetworkInterfaceRequest::~CreateNetworkInterfaceRequest()
 {}

+int CreateNetworkInterfaceRequest::getQueueNumber()const
+{
+	return queueNumber_;
+}
+
+void CreateNetworkInterfaceRequest::setQueueNumber(int queueNumber)
+{
+	queueNumber_ = queueNumber;
+	setParameter("QueueNumber", std::to_string(queueNumber));
+}
+
 long CreateNetworkInterfaceRequest::getResourceOwnerId()const
 {
 	return resourceOwnerId_;
--- a/ecs/src/model/DeleteDedicatedHostClusterRequest.cc
+++ b/ecs/src/model/DeleteDedicatedHostClusterRequest.cc
@@ -0,0 +1,95 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/ecs/model/DeleteDedicatedHostClusterRequest.h>
+
+using AlibabaCloud::Ecs::Model::DeleteDedicatedHostClusterRequest;
+
+DeleteDedicatedHostClusterRequest::DeleteDedicatedHostClusterRequest() :
+	RpcServiceRequest("ecs", "2014-05-26", "DeleteDedicatedHostCluster")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+DeleteDedicatedHostClusterRequest::~DeleteDedicatedHostClusterRequest()
+{}
+
+long DeleteDedicatedHostClusterRequest::getResourceOwnerId()const
+{
+	return resourceOwnerId_;
+}
+
+void DeleteDedicatedHostClusterRequest::setResourceOwnerId(long resourceOwnerId)
+{
+	resourceOwnerId_ = resourceOwnerId;
+	setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
+}
+
+std::string DeleteDedicatedHostClusterRequest::getRegionId()const
+{
+	return regionId_;
+}
+
+void DeleteDedicatedHostClusterRequest::setRegionId(const std::string& regionId)
+{
+	regionId_ = regionId;
+	setParameter("RegionId", regionId);
+}
+
+std::string DeleteDedicatedHostClusterRequest::getDedicatedHostClusterId()const
+{
+	return dedicatedHostClusterId_;
+}
+
+void DeleteDedicatedHostClusterRequest::setDedicatedHostClusterId(const std::string& dedicatedHostClusterId)
+{
+	dedicatedHostClusterId_ = dedicatedHostClusterId;
+	setParameter("DedicatedHostClusterId", dedicatedHostClusterId);
+}
+
+std::string DeleteDedicatedHostClusterRequest::getResourceOwnerAccount()const
+{
+	return resourceOwnerAccount_;
+}
+
+void DeleteDedicatedHostClusterRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
+{
+	resourceOwnerAccount_ = resourceOwnerAccount;
+	setParameter("ResourceOwnerAccount", resourceOwnerAccount);
+}
+
+std::string DeleteDedicatedHostClusterRequest::getOwnerAccount()const
+{
+	return ownerAccount_;
+}
+
+void DeleteDedicatedHostClusterRequest::setOwnerAccount(const std::string& ownerAccount)
+{
+	ownerAccount_ = ownerAccount;
+	setParameter("OwnerAccount", ownerAccount);
+}
+
+long DeleteDedicatedHostClusterRequest::getOwnerId()const
+{
+	return ownerId_;
+}
+
+void DeleteDedicatedHostClusterRequest::setOwnerId(long ownerId)
+{
+	ownerId_ = ownerId;
+	setParameter("OwnerId", std::to_string(ownerId));
+}
+
--- a/ecs/src/model/DeleteDedicatedHostClusterResult.cc
+++ b/ecs/src/model/DeleteDedicatedHostClusterResult.cc
@@ -0,0 +1,44 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/ecs/model/DeleteDedicatedHostClusterResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Ecs;
+using namespace AlibabaCloud::Ecs::Model;
+
+DeleteDedicatedHostClusterResult::DeleteDedicatedHostClusterResult() :
+	ServiceResult()
+{}
+
+DeleteDedicatedHostClusterResult::DeleteDedicatedHostClusterResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+DeleteDedicatedHostClusterResult::~DeleteDedicatedHostClusterResult()
+{}
+
+void DeleteDedicatedHostClusterResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+
+}
+
--- a/ecs/src/model/DescribeDedicatedHostClustersRequest.cc
+++ b/ecs/src/model/DescribeDedicatedHostClustersRequest.cc
@@ -0,0 +1,188 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/ecs/model/DescribeDedicatedHostClustersRequest.h>
+
+using AlibabaCloud::Ecs::Model::DescribeDedicatedHostClustersRequest;
+
+DescribeDedicatedHostClustersRequest::DescribeDedicatedHostClustersRequest() :
+	RpcServiceRequest("ecs", "2014-05-26", "DescribeDedicatedHostClusters")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+DescribeDedicatedHostClustersRequest::~DescribeDedicatedHostClustersRequest()
+{}
+
+std::string DescribeDedicatedHostClustersRequest::getDedicatedHostClusterName()const
+{
+	return dedicatedHostClusterName_;
+}
+
+void DescribeDedicatedHostClustersRequest::setDedicatedHostClusterName(const std::string& dedicatedHostClusterName)
+{
+	dedicatedHostClusterName_ = dedicatedHostClusterName;
+	setParameter("DedicatedHostClusterName", dedicatedHostClusterName);
+}
+
+long DescribeDedicatedHostClustersRequest::getResourceOwnerId()const
+{
+	return resourceOwnerId_;
+}
+
+void DescribeDedicatedHostClustersRequest::setResourceOwnerId(long resourceOwnerId)
+{
+	resourceOwnerId_ = resourceOwnerId;
+	setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
+}
+
+std::string DescribeDedicatedHostClustersRequest::getDedicatedHostClusterIds()const
+{
+	return dedicatedHostClusterIds_;
+}
+
+void DescribeDedicatedHostClustersRequest::setDedicatedHostClusterIds(const std::string& dedicatedHostClusterIds)
+{
+	dedicatedHostClusterIds_ = dedicatedHostClusterIds;
+	setParameter("DedicatedHostClusterIds", dedicatedHostClusterIds);
+}
+
+int DescribeDedicatedHostClustersRequest::getPageNumber()const
+{
+	return pageNumber_;
+}
+
+void DescribeDedicatedHostClustersRequest::setPageNumber(int pageNumber)
+{
+	pageNumber_ = pageNumber;
+	setParameter("PageNumber", std::to_string(pageNumber));
+}
+
+std::string DescribeDedicatedHostClustersRequest::getResourceGroupId()const
+{
+	return resourceGroupId_;
+}
+
+void DescribeDedicatedHostClustersRequest::setResourceGroupId(const std::string& resourceGroupId)
+{
+	resourceGroupId_ = resourceGroupId;
+	setParameter("ResourceGroupId", resourceGroupId);
+}
+
+std::string DescribeDedicatedHostClustersRequest::getLockReason()const
+{
+	return lockReason_;
+}
+
+void DescribeDedicatedHostClustersRequest::setLockReason(const std::string& lockReason)
+{
+	lockReason_ = lockReason;
+	setParameter("LockReason", lockReason);
+}
+
+std::string DescribeDedicatedHostClustersRequest::getRegionId()const
+{
+	return regionId_;
+}
+
+void DescribeDedicatedHostClustersRequest::setRegionId(const std::string& regionId)
+{
+	regionId_ = regionId;
+	setParameter("RegionId", regionId);
+}
+
+int DescribeDedicatedHostClustersRequest::getPageSize()const
+{
+	return pageSize_;
+}
+
+void DescribeDedicatedHostClustersRequest::setPageSize(int pageSize)
+{
+	pageSize_ = pageSize;
+	setParameter("PageSize", std::to_string(pageSize));
+}
+
+std::vector<DescribeDedicatedHostClustersRequest::Tag> DescribeDedicatedHostClustersRequest::getTag()const
+{
+	return tag_;
+}
+
+void DescribeDedicatedHostClustersRequest::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 + 1);
+		setParameter(tagObjStr + ".Key", tagObj.key);
+		setParameter(tagObjStr + ".Value", tagObj.value);
+	}
+}
+
+std::string DescribeDedicatedHostClustersRequest::getResourceOwnerAccount()const
+{
+	return resourceOwnerAccount_;
+}
+
+void DescribeDedicatedHostClustersRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
+{
+	resourceOwnerAccount_ = resourceOwnerAccount;
+	setParameter("ResourceOwnerAccount", resourceOwnerAccount);
+}
+
+std::string DescribeDedicatedHostClustersRequest::getOwnerAccount()const
+{
+	return ownerAccount_;
+}
+
+void DescribeDedicatedHostClustersRequest::setOwnerAccount(const std::string& ownerAccount)
+{
+	ownerAccount_ = ownerAccount;
+	setParameter("OwnerAccount", ownerAccount);
+}
+
+long DescribeDedicatedHostClustersRequest::getOwnerId()const
+{
+	return ownerId_;
+}
+
+void DescribeDedicatedHostClustersRequest::setOwnerId(long ownerId)
+{
+	ownerId_ = ownerId;
+	setParameter("OwnerId", std::to_string(ownerId));
+}
+
+std::string DescribeDedicatedHostClustersRequest::getZoneId()const
+{
+	return zoneId_;
+}
+
+void DescribeDedicatedHostClustersRequest::setZoneId(const std::string& zoneId)
+{
+	zoneId_ = zoneId;
+	setParameter("ZoneId", zoneId);
+}
+
+std::string DescribeDedicatedHostClustersRequest::getStatus()const
+{
+	return status_;
+}
+
+void DescribeDedicatedHostClustersRequest::setStatus(const std::string& status)
+{
+	status_ = status;
+	setParameter("Status", status);
+}
+
--- a/ecs/src/model/DescribeDedicatedHostClustersResult.cc
+++ b/ecs/src/model/DescribeDedicatedHostClustersResult.cc
@@ -0,0 +1,122 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/ecs/model/DescribeDedicatedHostClustersResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Ecs;
+using namespace AlibabaCloud::Ecs::Model;
+
+DescribeDedicatedHostClustersResult::DescribeDedicatedHostClustersResult() :
+	ServiceResult()
+{}
+
+DescribeDedicatedHostClustersResult::DescribeDedicatedHostClustersResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+DescribeDedicatedHostClustersResult::~DescribeDedicatedHostClustersResult()
+{}
+
+void DescribeDedicatedHostClustersResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto allDedicatedHostClustersNode = value["DedicatedHostClusters"]["DedicatedHostCluster"];
+	for (auto valueDedicatedHostClustersDedicatedHostCluster : allDedicatedHostClustersNode)
+	{
+		DedicatedHostCluster dedicatedHostClustersObject;
+		if(!valueDedicatedHostClustersDedicatedHostCluster["DedicatedHostClusterId"].isNull())
+			dedicatedHostClustersObject.dedicatedHostClusterId = valueDedicatedHostClustersDedicatedHostCluster["DedicatedHostClusterId"].asString();
+		if(!valueDedicatedHostClustersDedicatedHostCluster["RegionId"].isNull())
+			dedicatedHostClustersObject.regionId = valueDedicatedHostClustersDedicatedHostCluster["RegionId"].asString();
+		if(!valueDedicatedHostClustersDedicatedHostCluster["ZoneId"].isNull())
+			dedicatedHostClustersObject.zoneId = valueDedicatedHostClustersDedicatedHostCluster["ZoneId"].asString();
+		if(!valueDedicatedHostClustersDedicatedHostCluster["DedicatedHostClusterName"].isNull())
+			dedicatedHostClustersObject.dedicatedHostClusterName = valueDedicatedHostClustersDedicatedHostCluster["DedicatedHostClusterName"].asString();
+		if(!valueDedicatedHostClustersDedicatedHostCluster["Description"].isNull())
+			dedicatedHostClustersObject.description = valueDedicatedHostClustersDedicatedHostCluster["Description"].asString();
+		if(!valueDedicatedHostClustersDedicatedHostCluster["ResourceGroupId"].isNull())
+			dedicatedHostClustersObject.resourceGroupId = valueDedicatedHostClustersDedicatedHostCluster["ResourceGroupId"].asString();
+		auto allTagsNode = allDedicatedHostClustersNode["Tags"]["Tag"];
+		for (auto allDedicatedHostClustersNodeTagsTag : allTagsNode)
+		{
+			DedicatedHostCluster::Tag tagsObject;
+			if(!allDedicatedHostClustersNodeTagsTag["TagKey"].isNull())
+				tagsObject.tagKey = allDedicatedHostClustersNodeTagsTag["TagKey"].asString();
+			if(!allDedicatedHostClustersNodeTagsTag["TagValue"].isNull())
+				tagsObject.tagValue = allDedicatedHostClustersNodeTagsTag["TagValue"].asString();
+			dedicatedHostClustersObject.tags.push_back(tagsObject);
+		}
+		auto dedicatedHostClusterCapacityNode = value["DedicatedHostClusterCapacity"];
+		if(!dedicatedHostClusterCapacityNode["TotalVcpus"].isNull())
+			dedicatedHostClustersObject.dedicatedHostClusterCapacity.totalVcpus = std::stoi(dedicatedHostClusterCapacityNode["TotalVcpus"].asString());
+		if(!dedicatedHostClusterCapacityNode["AvailableVcpus"].isNull())
+			dedicatedHostClustersObject.dedicatedHostClusterCapacity.availableVcpus = std::stoi(dedicatedHostClusterCapacityNode["AvailableVcpus"].asString());
+		if(!dedicatedHostClusterCapacityNode["TotalMemory"].isNull())
+			dedicatedHostClustersObject.dedicatedHostClusterCapacity.totalMemory = std::stoi(dedicatedHostClusterCapacityNode["TotalMemory"].asString());
+		if(!dedicatedHostClusterCapacityNode["AvailableMemory"].isNull())
+			dedicatedHostClustersObject.dedicatedHostClusterCapacity.availableMemory = std::stoi(dedicatedHostClusterCapacityNode["AvailableMemory"].asString());
+		auto allLocalStorageCapacitiesNode = dedicatedHostClusterCapacityNode["LocalStorageCapacities"]["LocalStorageCapacity"];
+		for (auto dedicatedHostClusterCapacityNodeLocalStorageCapacitiesLocalStorageCapacity : allLocalStorageCapacitiesNode)
+		{
+			DedicatedHostCluster::DedicatedHostClusterCapacity::LocalStorageCapacity localStorageCapacityObject;
+			if(!dedicatedHostClusterCapacityNodeLocalStorageCapacitiesLocalStorageCapacity["TotalDisk"].isNull())
+				localStorageCapacityObject.totalDisk = std::stoi(dedicatedHostClusterCapacityNodeLocalStorageCapacitiesLocalStorageCapacity["TotalDisk"].asString());
+			if(!dedicatedHostClusterCapacityNodeLocalStorageCapacitiesLocalStorageCapacity["AvailableDisk"].isNull())
+				localStorageCapacityObject.availableDisk = std::stoi(dedicatedHostClusterCapacityNodeLocalStorageCapacitiesLocalStorageCapacity["AvailableDisk"].asString());
+			if(!dedicatedHostClusterCapacityNodeLocalStorageCapacitiesLocalStorageCapacity["DataDiskCategory"].isNull())
+				localStorageCapacityObject.dataDiskCategory = dedicatedHostClusterCapacityNodeLocalStorageCapacitiesLocalStorageCapacity["DataDiskCategory"].asString();
+			dedicatedHostClustersObject.dedicatedHostClusterCapacity.localStorageCapacities.push_back(localStorageCapacityObject);
+		}
+		auto allDedicatedHostIds = value["DedicatedHostIds"]["DedicatedHostId"];
+		for (auto value : allDedicatedHostIds)
+			dedicatedHostClustersObject.dedicatedHostIds.push_back(value.asString());
+		dedicatedHostClusters_.push_back(dedicatedHostClustersObject);
+	}
+	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<DescribeDedicatedHostClustersResult::DedicatedHostCluster> DescribeDedicatedHostClustersResult::getDedicatedHostClusters()const
+{
+	return dedicatedHostClusters_;
+}
+
+int DescribeDedicatedHostClustersResult::getTotalCount()const
+{
+	return totalCount_;
+}
+
+int DescribeDedicatedHostClustersResult::getPageSize()const
+{
+	return pageSize_;
+}
+
+int DescribeDedicatedHostClustersResult::getPageNumber()const
+{
+	return pageNumber_;
+}
+
--- a/ecs/src/model/DescribeDedicatedHostTypesResult.cc
+++ b/ecs/src/model/DescribeDedicatedHostTypesResult.cc
@@ -65,6 +65,10 @@ void DescribeDedicatedHostTypesResult::parse(const std::string &payload)
 			dedicatedHostTypesObject.localStorageCategory = valueDedicatedHostTypesDedicatedHostType["LocalStorageCategory"].asString();
 		if(!valueDedicatedHostTypesDedicatedHostType["GPUSpec"].isNull())
 			dedicatedHostTypesObject.gPUSpec = valueDedicatedHostTypesDedicatedHostType["GPUSpec"].asString();
+		if(!valueDedicatedHostTypesDedicatedHostType["SupportCpuOverCommitRatio"].isNull())
+			dedicatedHostTypesObject.supportCpuOverCommitRatio = valueDedicatedHostTypesDedicatedHostType["SupportCpuOverCommitRatio"].asString() == "true";
+		if(!valueDedicatedHostTypesDedicatedHostType["CpuOverCommitRatioRange"].isNull())
+			dedicatedHostTypesObject.cpuOverCommitRatioRange = valueDedicatedHostTypesDedicatedHostType["CpuOverCommitRatioRange"].asString();
 		auto allSupportedInstanceTypeFamilies = value["SupportedInstanceTypeFamilies"]["SupportedInstanceTypeFamily"];
 		for (auto value : allSupportedInstanceTypeFamilies)
 			dedicatedHostTypesObject.supportedInstanceTypeFamilies.push_back(value.asString());
--- a/ecs/src/model/DescribeDedicatedHostsResult.cc
+++ b/ecs/src/model/DescribeDedicatedHostsResult.cc
@@ -83,6 +83,10 @@ void DescribeDedicatedHostsResult::parse(const std::string &payload)
 			dedicatedHostsObject.autoReleaseTime = valueDedicatedHostsDedicatedHost["AutoReleaseTime"].asString();
 		if(!valueDedicatedHostsDedicatedHost["ResourceGroupId"].isNull())
 			dedicatedHostsObject.resourceGroupId = valueDedicatedHostsDedicatedHost["ResourceGroupId"].asString();
+		if(!valueDedicatedHostsDedicatedHost["DedicatedHostClusterId"].isNull())
+			dedicatedHostsObject.dedicatedHostClusterId = valueDedicatedHostsDedicatedHost["DedicatedHostClusterId"].asString();
+		if(!valueDedicatedHostsDedicatedHost["CpuOverCommitRatio"].isNull())
+			dedicatedHostsObject.cpuOverCommitRatio = std::stof(valueDedicatedHostsDedicatedHost["CpuOverCommitRatio"].asString());
 		auto allInstancesNode = allDedicatedHostsNode["Instances"]["Instance"];
 		for (auto allDedicatedHostsNodeInstancesInstance : allInstancesNode)
 		{
--- a/ecs/src/model/DescribeDisksRequest.cc
+++ b/ecs/src/model/DescribeDisksRequest.cc
@@ -232,6 +232,17 @@ void DescribeDisksRequest::setZoneId(const std::string& zoneId)
 	setParameter("ZoneId", zoneId);
 }

+int DescribeDisksRequest::getMaxResults()const
+{
+	return maxResults_;
+}
+
+void DescribeDisksRequest::setMaxResults(int maxResults)
+{
+	maxResults_ = maxResults;
+	setParameter("MaxResults", std::to_string(maxResults));
+}
+
 std::string DescribeDisksRequest::getStatus()const
 {
 	return status_;
@@ -276,6 +287,17 @@ void DescribeDisksRequest::setRegionId(const std::string& regionId)
 	setParameter("RegionId", regionId);
 }

+std::string DescribeDisksRequest::getNextToken()const
+{
+	return nextToken_;
+}
+
+void DescribeDisksRequest::setNextToken(const std::string& nextToken)
+{
+	nextToken_ = nextToken;
+	setParameter("NextToken", nextToken);
+}
+
 int DescribeDisksRequest::getPageSize()const
 {
 	return pageSize_;
--- a/ecs/src/model/DescribeDisksResult.cc
+++ b/ecs/src/model/DescribeDisksResult.cc
@@ -155,6 +155,8 @@ void DescribeDisksResult::parse(const std::string &payload)
 		pageNumber_ = std::stoi(value["PageNumber"].asString());
 	if(!value["PageSize"].isNull())
 		pageSize_ = std::stoi(value["PageSize"].asString());
+	if(!value["NextToken"].isNull())
+		nextToken_ = value["NextToken"].asString();

 }

@@ -168,6 +170,11 @@ int DescribeDisksResult::getPageSize()const
 	return pageSize_;
 }

+std::string DescribeDisksResult::getNextToken()const
+{
+	return nextToken_;
+}
+
 int DescribeDisksResult::getPageNumber()const
 {
 	return pageNumber_;
--- a/ecs/src/model/DescribeInstanceTypesResult.cc
+++ b/ecs/src/model/DescribeInstanceTypesResult.cc
@@ -87,6 +87,12 @@ void DescribeInstanceTypesResult::parse(const std::string &payload)
 			instanceTypesObject.eniTrunkSupported = valueInstanceTypesInstanceType["EniTrunkSupported"].asString() == "true";
 		if(!valueInstanceTypesInstanceType["EniTotalQuantity"].isNull())
 			instanceTypesObject.eniTotalQuantity = std::stoi(valueInstanceTypesInstanceType["EniTotalQuantity"].asString());
+		if(!valueInstanceTypesInstanceType["MaximumQueueNumberPerEni"].isNull())
+			instanceTypesObject.maximumQueueNumberPerEni = std::stoi(valueInstanceTypesInstanceType["MaximumQueueNumberPerEni"].asString());
+		if(!valueInstanceTypesInstanceType["PrimaryEniQueueNumber"].isNull())
+			instanceTypesObject.primaryEniQueueNumber = std::stoi(valueInstanceTypesInstanceType["PrimaryEniQueueNumber"].asString());
+		if(!valueInstanceTypesInstanceType["SecondaryEniQueueNumber"].isNull())
+			instanceTypesObject.secondaryEniQueueNumber = std::stoi(valueInstanceTypesInstanceType["SecondaryEniQueueNumber"].asString());
 		instanceTypes_.push_back(instanceTypesObject);
 	}

--- a/ecs/src/model/DescribeInstancesResult.cc
+++ b/ecs/src/model/DescribeInstancesResult.cc
@@ -119,6 +119,8 @@ void DescribeInstancesResult::parse(const std::string &payload)
 			instancesObject.spotStrategy = valueInstancesInstance["SpotStrategy"].asString();
 		if(!valueInstancesInstance["SpotPriceLimit"].isNull())
 			instancesObject.spotPriceLimit = std::stof(valueInstancesInstance["SpotPriceLimit"].asString());
+		if(!valueInstancesInstance["SpotDuration"].isNull())
+			instancesObject.spotDuration = std::stoi(valueInstancesInstance["SpotDuration"].asString());
 		if(!valueInstancesInstance["ResourceGroupId"].isNull())
 			instancesObject.resourceGroupId = valueInstancesInstance["ResourceGroupId"].asString();
 		if(!valueInstancesInstance["KeyPairName"].isNull())
@@ -191,6 +193,8 @@ void DescribeInstancesResult::parse(const std::string &payload)
 			instancesObject.dedicatedHostAttribute.dedicatedHostId = dedicatedHostAttributeNode["DedicatedHostId"].asString();
 		if(!dedicatedHostAttributeNode["DedicatedHostName"].isNull())
 			instancesObject.dedicatedHostAttribute.dedicatedHostName = dedicatedHostAttributeNode["DedicatedHostName"].asString();
+		if(!dedicatedHostAttributeNode["DedicatedHostClusterId"].isNull())
+			instancesObject.dedicatedHostAttribute.dedicatedHostClusterId = dedicatedHostAttributeNode["DedicatedHostClusterId"].asString();
 		auto ecsCapacityReservationAttrNode = value["EcsCapacityReservationAttr"];
 		if(!ecsCapacityReservationAttrNode["CapacityReservationId"].isNull())
 			instancesObject.ecsCapacityReservationAttr.capacityReservationId = ecsCapacityReservationAttrNode["CapacityReservationId"].asString();
--- a/ecs/src/model/DescribeReservedInstancesRequest.cc
+++ b/ecs/src/model/DescribeReservedInstancesRequest.cc
@@ -104,6 +104,22 @@ void DescribeReservedInstancesRequest::setInstanceType(const std::string& instan
 	setParameter("InstanceType", instanceType);
 }

+std::vector<DescribeReservedInstancesRequest::Tag> DescribeReservedInstancesRequest::getTag()const
+{
+	return tag_;
+}
+
+void DescribeReservedInstancesRequest::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 + 1);
+		setParameter(tagObjStr + ".Key", tagObj.key);
+		setParameter(tagObjStr + ".Value", tagObj.value);
+	}
+}
+
 std::string DescribeReservedInstancesRequest::getResourceOwnerAccount()const
 {
 	return resourceOwnerAccount_;
--- a/ecs/src/model/DescribeReservedInstancesResult.cc
+++ b/ecs/src/model/DescribeReservedInstancesResult.cc
@@ -83,6 +83,16 @@ void DescribeReservedInstancesResult::parse(const std::string &payload)
 				operationLocksObject.lockReason = allReservedInstancesNodeOperationLocksOperationLock["LockReason"].asString();
 			reservedInstancesObject.operationLocks.push_back(operationLocksObject);
 		}
+		auto allTagsNode = allReservedInstancesNode["Tags"]["Tag"];
+		for (auto allReservedInstancesNodeTagsTag : allTagsNode)
+		{
+			ReservedInstance::Tag tagsObject;
+			if(!allReservedInstancesNodeTagsTag["TagKey"].isNull())
+				tagsObject.tagKey = allReservedInstancesNodeTagsTag["TagKey"].asString();
+			if(!allReservedInstancesNodeTagsTag["TagValue"].isNull())
+				tagsObject.tagValue = allReservedInstancesNodeTagsTag["TagValue"].asString();
+			reservedInstancesObject.tags.push_back(tagsObject);
+		}
 		reservedInstances_.push_back(reservedInstancesObject);
 	}
 	if(!value["TotalCount"].isNull())
--- a/ecs/src/model/DescribeSendFileResultsRequest.cc
+++ b/ecs/src/model/DescribeSendFileResultsRequest.cc
@@ -0,0 +1,139 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/ecs/model/DescribeSendFileResultsRequest.h>
+
+using AlibabaCloud::Ecs::Model::DescribeSendFileResultsRequest;
+
+DescribeSendFileResultsRequest::DescribeSendFileResultsRequest() :
+	RpcServiceRequest("ecs", "2014-05-26", "DescribeSendFileResults")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+DescribeSendFileResultsRequest::~DescribeSendFileResultsRequest()
+{}
+
+long DescribeSendFileResultsRequest::getResourceOwnerId()const
+{
+	return resourceOwnerId_;
+}
+
+void DescribeSendFileResultsRequest::setResourceOwnerId(long resourceOwnerId)
+{
+	resourceOwnerId_ = resourceOwnerId;
+	setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
+}
+
+long DescribeSendFileResultsRequest::getPageNumber()const
+{
+	return pageNumber_;
+}
+
+void DescribeSendFileResultsRequest::setPageNumber(long pageNumber)
+{
+	pageNumber_ = pageNumber;
+	setParameter("PageNumber", std::to_string(pageNumber));
+}
+
+std::string DescribeSendFileResultsRequest::getRegionId()const
+{
+	return regionId_;
+}
+
+void DescribeSendFileResultsRequest::setRegionId(const std::string& regionId)
+{
+	regionId_ = regionId;
+	setParameter("RegionId", regionId);
+}
+
+long DescribeSendFileResultsRequest::getPageSize()const
+{
+	return pageSize_;
+}
+
+void DescribeSendFileResultsRequest::setPageSize(long pageSize)
+{
+	pageSize_ = pageSize;
+	setParameter("PageSize", std::to_string(pageSize));
+}
+
+std::string DescribeSendFileResultsRequest::getInvokeId()const
+{
+	return invokeId_;
+}
+
+void DescribeSendFileResultsRequest::setInvokeId(const std::string& invokeId)
+{
+	invokeId_ = invokeId;
+	setParameter("InvokeId", invokeId);
+}
+
+std::string DescribeSendFileResultsRequest::getResourceOwnerAccount()const
+{
+	return resourceOwnerAccount_;
+}
+
+void DescribeSendFileResultsRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
+{
+	resourceOwnerAccount_ = resourceOwnerAccount;
+	setParameter("ResourceOwnerAccount", resourceOwnerAccount);
+}
+
+std::string DescribeSendFileResultsRequest::getOwnerAccount()const
+{
+	return ownerAccount_;
+}
+
+void DescribeSendFileResultsRequest::setOwnerAccount(const std::string& ownerAccount)
+{
+	ownerAccount_ = ownerAccount;
+	setParameter("OwnerAccount", ownerAccount);
+}
+
+long DescribeSendFileResultsRequest::getOwnerId()const
+{
+	return ownerId_;
+}
+
+void DescribeSendFileResultsRequest::setOwnerId(long ownerId)
+{
+	ownerId_ = ownerId;
+	setParameter("OwnerId", std::to_string(ownerId));
+}
+
+std::string DescribeSendFileResultsRequest::getInstanceId()const
+{
+	return instanceId_;
+}
+
+void DescribeSendFileResultsRequest::setInstanceId(const std::string& instanceId)
+{
+	instanceId_ = instanceId;
+	setParameter("InstanceId", instanceId);
+}
+
+std::string DescribeSendFileResultsRequest::getName()const
+{
+	return name_;
+}
+
+void DescribeSendFileResultsRequest::setName(const std::string& name)
+{
+	name_ = name;
+	setParameter("Name", name);
+}
+
--- a/ecs/src/model/DescribeSendFileResultsResult.cc
+++ b/ecs/src/model/DescribeSendFileResultsResult.cc
@@ -0,0 +1,124 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/ecs/model/DescribeSendFileResultsResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Ecs;
+using namespace AlibabaCloud::Ecs::Model;
+
+DescribeSendFileResultsResult::DescribeSendFileResultsResult() :
+	ServiceResult()
+{}
+
+DescribeSendFileResultsResult::DescribeSendFileResultsResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+DescribeSendFileResultsResult::~DescribeSendFileResultsResult()
+{}
+
+void DescribeSendFileResultsResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto allInvocationsNode = value["Invocations"]["Invocation"];
+	for (auto valueInvocationsInvocation : allInvocationsNode)
+	{
+		Invocation invocationsObject;
+		if(!valueInvocationsInvocation["InvokeId"].isNull())
+			invocationsObject.invokeId = valueInvocationsInvocation["InvokeId"].asString();
+		if(!valueInvocationsInvocation["Name"].isNull())
+			invocationsObject.name = valueInvocationsInvocation["Name"].asString();
+		if(!valueInvocationsInvocation["Description"].isNull())
+			invocationsObject.description = valueInvocationsInvocation["Description"].asString();
+		if(!valueInvocationsInvocation["TargetDir"].isNull())
+			invocationsObject.targetDir = valueInvocationsInvocation["TargetDir"].asString();
+		if(!valueInvocationsInvocation["ContentType"].isNull())
+			invocationsObject.contentType = valueInvocationsInvocation["ContentType"].asString();
+		if(!valueInvocationsInvocation["Content"].isNull())
+			invocationsObject.content = valueInvocationsInvocation["Content"].asString();
+		if(!valueInvocationsInvocation["FileOwner"].isNull())
+			invocationsObject.fileOwner = valueInvocationsInvocation["FileOwner"].asString();
+		if(!valueInvocationsInvocation["FileGroup"].isNull())
+			invocationsObject.fileGroup = valueInvocationsInvocation["FileGroup"].asString();
+		if(!valueInvocationsInvocation["FileMode"].isNull())
+			invocationsObject.fileMode = valueInvocationsInvocation["FileMode"].asString();
+		if(!valueInvocationsInvocation["Overwrite"].isNull())
+			invocationsObject.overwrite = valueInvocationsInvocation["Overwrite"].asString();
+		if(!valueInvocationsInvocation["VmCount"].isNull())
+			invocationsObject.vmCount = std::stoi(valueInvocationsInvocation["VmCount"].asString());
+		if(!valueInvocationsInvocation["CreationTime"].isNull())
+			invocationsObject.creationTime = valueInvocationsInvocation["CreationTime"].asString();
+		if(!valueInvocationsInvocation["InvocationStatus"].isNull())
+			invocationsObject.invocationStatus = valueInvocationsInvocation["InvocationStatus"].asString();
+		auto allInvokeInstancesNode = allInvocationsNode["InvokeInstances"]["InvokeInstance"];
+		for (auto allInvocationsNodeInvokeInstancesInvokeInstance : allInvokeInstancesNode)
+		{
+			Invocation::InvokeInstance invokeInstancesObject;
+			if(!allInvocationsNodeInvokeInstancesInvokeInstance["InstanceId"].isNull())
+				invokeInstancesObject.instanceId = allInvocationsNodeInvokeInstancesInvokeInstance["InstanceId"].asString();
+			if(!allInvocationsNodeInvokeInstancesInvokeInstance["InvocationStatus"].isNull())
+				invokeInstancesObject.invocationStatus = allInvocationsNodeInvokeInstancesInvokeInstance["InvocationStatus"].asString();
+			if(!allInvocationsNodeInvokeInstancesInvokeInstance["CreationTime"].isNull())
+				invokeInstancesObject.creationTime = allInvocationsNodeInvokeInstancesInvokeInstance["CreationTime"].asString();
+			if(!allInvocationsNodeInvokeInstancesInvokeInstance["StartTime"].isNull())
+				invokeInstancesObject.startTime = allInvocationsNodeInvokeInstancesInvokeInstance["StartTime"].asString();
+			if(!allInvocationsNodeInvokeInstancesInvokeInstance["FinishTime"].isNull())
+				invokeInstancesObject.finishTime = allInvocationsNodeInvokeInstancesInvokeInstance["FinishTime"].asString();
+			if(!allInvocationsNodeInvokeInstancesInvokeInstance["UpdateTime"].isNull())
+				invokeInstancesObject.updateTime = allInvocationsNodeInvokeInstancesInvokeInstance["UpdateTime"].asString();
+			if(!allInvocationsNodeInvokeInstancesInvokeInstance["ErrorCode"].isNull())
+				invokeInstancesObject.errorCode = allInvocationsNodeInvokeInstancesInvokeInstance["ErrorCode"].asString();
+			if(!allInvocationsNodeInvokeInstancesInvokeInstance["ErrorInfo"].isNull())
+				invokeInstancesObject.errorInfo = allInvocationsNodeInvokeInstancesInvokeInstance["ErrorInfo"].asString();
+			invocationsObject.invokeInstances.push_back(invokeInstancesObject);
+		}
+		invocations_.push_back(invocationsObject);
+	}
+	if(!value["TotalCount"].isNull())
+		totalCount_ = std::stol(value["TotalCount"].asString());
+	if(!value["PageNumber"].isNull())
+		pageNumber_ = std::stol(value["PageNumber"].asString());
+	if(!value["PageSize"].isNull())
+		pageSize_ = std::stol(value["PageSize"].asString());
+
+}
+
+long DescribeSendFileResultsResult::getTotalCount()const
+{
+	return totalCount_;
+}
+
+long DescribeSendFileResultsResult::getPageSize()const
+{
+	return pageSize_;
+}
+
+std::vector<DescribeSendFileResultsResult::Invocation> DescribeSendFileResultsResult::getInvocations()const
+{
+	return invocations_;
+}
+
+long DescribeSendFileResultsResult::getPageNumber()const
+{
+	return pageNumber_;
+}
+
--- a/ecs/src/model/DescribeTagsResult.cc
+++ b/ecs/src/model/DescribeTagsResult.cc
@@ -70,6 +70,8 @@ void DescribeTagsResult::parse(const std::string &payload)
 			tagsObject.resourceTypeCount.keyPair = std::stoi(resourceTypeCountNode["KeyPair"].asString());
 		if(!resourceTypeCountNode["SnapshotPolicy"].isNull())
 			tagsObject.resourceTypeCount.snapshotPolicy = std::stoi(resourceTypeCountNode["SnapshotPolicy"].asString());
+		if(!resourceTypeCountNode["ReservedInstance"].isNull())
+			tagsObject.resourceTypeCount.reservedInstance = std::stoi(resourceTypeCountNode["ReservedInstance"].asString());
 		tags_.push_back(tagsObject);
 	}
 	if(!value["PageSize"].isNull())
--- a/ecs/src/model/ModifyDedicatedHostAttributeRequest.cc
+++ b/ecs/src/model/ModifyDedicatedHostAttributeRequest.cc
@@ -49,6 +49,17 @@ void ModifyDedicatedHostAttributeRequest::setDescription(const std::string& desc
 	setParameter("Description", description);
 }

+float ModifyDedicatedHostAttributeRequest::getCpuOverCommitRatio()const
+{
+	return cpuOverCommitRatio_;
+}
+
+void ModifyDedicatedHostAttributeRequest::setCpuOverCommitRatio(float cpuOverCommitRatio)
+{
+	cpuOverCommitRatio_ = cpuOverCommitRatio;
+	setParameter("CpuOverCommitRatio", std::to_string(cpuOverCommitRatio));
+}
+
 std::string ModifyDedicatedHostAttributeRequest::getRegionId()const
 {
 	return regionId_;
@@ -71,6 +82,17 @@ void ModifyDedicatedHostAttributeRequest::setActionOnMaintenance(const std::stri
 	setParameter("ActionOnMaintenance", actionOnMaintenance);
 }

+std::string ModifyDedicatedHostAttributeRequest::getDedicatedHostClusterId()const
+{
+	return dedicatedHostClusterId_;
+}
+
+void ModifyDedicatedHostAttributeRequest::setDedicatedHostClusterId(const std::string& dedicatedHostClusterId)
+{
+	dedicatedHostClusterId_ = dedicatedHostClusterId;
+	setParameter("DedicatedHostClusterId", dedicatedHostClusterId);
+}
+
 std::string ModifyDedicatedHostAttributeRequest::getDedicatedHostName()const
 {
 	return dedicatedHostName_;
--- a/ecs/src/model/ModifyDedicatedHostClusterAttributeRequest.cc
+++ b/ecs/src/model/ModifyDedicatedHostClusterAttributeRequest.cc
@@ -0,0 +1,117 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/ecs/model/ModifyDedicatedHostClusterAttributeRequest.h>
+
+using AlibabaCloud::Ecs::Model::ModifyDedicatedHostClusterAttributeRequest;
+
+ModifyDedicatedHostClusterAttributeRequest::ModifyDedicatedHostClusterAttributeRequest() :
+	RpcServiceRequest("ecs", "2014-05-26", "ModifyDedicatedHostClusterAttribute")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+ModifyDedicatedHostClusterAttributeRequest::~ModifyDedicatedHostClusterAttributeRequest()
+{}
+
+std::string ModifyDedicatedHostClusterAttributeRequest::getDedicatedHostClusterName()const
+{
+	return dedicatedHostClusterName_;
+}
+
+void ModifyDedicatedHostClusterAttributeRequest::setDedicatedHostClusterName(const std::string& dedicatedHostClusterName)
+{
+	dedicatedHostClusterName_ = dedicatedHostClusterName;
+	setParameter("DedicatedHostClusterName", dedicatedHostClusterName);
+}
+
+long ModifyDedicatedHostClusterAttributeRequest::getResourceOwnerId()const
+{
+	return resourceOwnerId_;
+}
+
+void ModifyDedicatedHostClusterAttributeRequest::setResourceOwnerId(long resourceOwnerId)
+{
+	resourceOwnerId_ = resourceOwnerId;
+	setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
+}
+
+std::string ModifyDedicatedHostClusterAttributeRequest::getDescription()const
+{
+	return description_;
+}
+
+void ModifyDedicatedHostClusterAttributeRequest::setDescription(const std::string& description)
+{
+	description_ = description;
+	setParameter("Description", description);
+}
+
+std::string ModifyDedicatedHostClusterAttributeRequest::getRegionId()const
+{
+	return regionId_;
+}
+
+void ModifyDedicatedHostClusterAttributeRequest::setRegionId(const std::string& regionId)
+{
+	regionId_ = regionId;
+	setParameter("RegionId", regionId);
+}
+
+std::string ModifyDedicatedHostClusterAttributeRequest::getDedicatedHostClusterId()const
+{
+	return dedicatedHostClusterId_;
+}
+
+void ModifyDedicatedHostClusterAttributeRequest::setDedicatedHostClusterId(const std::string& dedicatedHostClusterId)
+{
+	dedicatedHostClusterId_ = dedicatedHostClusterId;
+	setParameter("DedicatedHostClusterId", dedicatedHostClusterId);
+}
+
+std::string ModifyDedicatedHostClusterAttributeRequest::getResourceOwnerAccount()const
+{
+	return resourceOwnerAccount_;
+}
+
+void ModifyDedicatedHostClusterAttributeRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
+{
+	resourceOwnerAccount_ = resourceOwnerAccount;
+	setParameter("ResourceOwnerAccount", resourceOwnerAccount);
+}
+
+std::string ModifyDedicatedHostClusterAttributeRequest::getOwnerAccount()const
+{
+	return ownerAccount_;
+}
+
+void ModifyDedicatedHostClusterAttributeRequest::setOwnerAccount(const std::string& ownerAccount)
+{
+	ownerAccount_ = ownerAccount;
+	setParameter("OwnerAccount", ownerAccount);
+}
+
+long ModifyDedicatedHostClusterAttributeRequest::getOwnerId()const
+{
+	return ownerId_;
+}
+
+void ModifyDedicatedHostClusterAttributeRequest::setOwnerId(long ownerId)
+{
+	ownerId_ = ownerId;
+	setParameter("OwnerId", std::to_string(ownerId));
+}
+
--- a/ecs/src/model/ModifyDedicatedHostClusterAttributeResult.cc
+++ b/ecs/src/model/ModifyDedicatedHostClusterAttributeResult.cc
@@ -0,0 +1,44 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/ecs/model/ModifyDedicatedHostClusterAttributeResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Ecs;
+using namespace AlibabaCloud::Ecs::Model;
+
+ModifyDedicatedHostClusterAttributeResult::ModifyDedicatedHostClusterAttributeResult() :
+	ServiceResult()
+{}
+
+ModifyDedicatedHostClusterAttributeResult::ModifyDedicatedHostClusterAttributeResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+ModifyDedicatedHostClusterAttributeResult::~ModifyDedicatedHostClusterAttributeResult()
+{}
+
+void ModifyDedicatedHostClusterAttributeResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+
+}
+
--- a/ecs/src/model/ModifyInstanceAttributeRequest.cc
+++ b/ecs/src/model/ModifyInstanceAttributeRequest.cc
@@ -49,6 +49,17 @@ void ModifyInstanceAttributeRequest::setRecyclable(bool recyclable)
 	setParameter("Recyclable", recyclable ? "true" : "false");
 }

+int ModifyInstanceAttributeRequest::getNetworkInterfaceQueueNumber()const
+{
+	return networkInterfaceQueueNumber_;
+}
+
+void ModifyInstanceAttributeRequest::setNetworkInterfaceQueueNumber(int networkInterfaceQueueNumber)
+{
+	networkInterfaceQueueNumber_ = networkInterfaceQueueNumber;
+	setParameter("NetworkInterfaceQueueNumber", std::to_string(networkInterfaceQueueNumber));
+}
+
 std::string ModifyInstanceAttributeRequest::getDescription()const
 {
 	return description_;
--- a/ecs/src/model/ModifyInstanceDeploymentRequest.cc
+++ b/ecs/src/model/ModifyInstanceDeploymentRequest.cc
@@ -60,6 +60,17 @@ void ModifyInstanceDeploymentRequest::setDeploymentSetGroupNo(int deploymentSetG
 	setParameter("DeploymentSetGroupNo", std::to_string(deploymentSetGroupNo));
 }

+std::string ModifyInstanceDeploymentRequest::getDedicatedHostClusterId()const
+{
+	return dedicatedHostClusterId_;
+}
+
+void ModifyInstanceDeploymentRequest::setDedicatedHostClusterId(const std::string& dedicatedHostClusterId)
+{
+	dedicatedHostClusterId_ = dedicatedHostClusterId;
+	setParameter("DedicatedHostClusterId", dedicatedHostClusterId);
+}
+
 std::string ModifyInstanceDeploymentRequest::getInstanceType()const
 {
 	return instanceType_;
--- a/ecs/src/model/PurchaseReservedInstancesOfferingRequest.cc
+++ b/ecs/src/model/PurchaseReservedInstancesOfferingRequest.cc
@@ -115,6 +115,22 @@ void PurchaseReservedInstancesOfferingRequest::setInstanceType(const std::string
 	setParameter("InstanceType", instanceType);
 }

+std::vector<PurchaseReservedInstancesOfferingRequest::Tag> PurchaseReservedInstancesOfferingRequest::getTag()const
+{
+	return tag_;
+}
+
+void PurchaseReservedInstancesOfferingRequest::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 + 1);
+		setParameter(tagObjStr + ".Key", tagObj.key);
+		setParameter(tagObjStr + ".Value", tagObj.value);
+	}
+}
+
 int PurchaseReservedInstancesOfferingRequest::getPeriod()const
 {
 	return period_;
--- a/ecs/src/model/RunInstancesRequest.cc
+++ b/ecs/src/model/RunInstancesRequest.cc
@@ -280,6 +280,17 @@ void RunInstancesRequest::setSpotInterruptionBehavior(const std::string& spotInt
 	setParameter("SpotInterruptionBehavior", spotInterruptionBehavior);
 }

+int RunInstancesRequest::getNetworkInterfaceQueueNumber()const
+{
+	return networkInterfaceQueueNumber_;
+}
+
+void RunInstancesRequest::setNetworkInterfaceQueueNumber(int networkInterfaceQueueNumber)
+{
+	networkInterfaceQueueNumber_ = networkInterfaceQueueNumber;
+	setParameter("NetworkInterfaceQueueNumber", std::to_string(networkInterfaceQueueNumber));
+}
+
 std::string RunInstancesRequest::getIoOptimized()const
 {
 	return ioOptimized_;
@@ -363,6 +374,17 @@ void RunInstancesRequest::setArn(const std::vector<Arn>& arn)
 	}
 }

+std::string RunInstancesRequest::getSchedulerOptions()const
+{
+	return schedulerOptions_;
+}
+
+void RunInstancesRequest::setSchedulerOptions(const std::string& schedulerOptions)
+{
+	schedulerOptions_ = schedulerOptions;
+	setParameter("SchedulerOptions", schedulerOptions);
+}
+
 std::string RunInstancesRequest::getResourceOwnerAccount()const
 {
 	return resourceOwnerAccount_;
@@ -754,6 +776,7 @@ void RunInstancesRequest::setNetworkInterface(const std::vector<NetworkInterface
 		}
 		setParameter(networkInterfaceObjStr + ".NetworkInterfaceName", networkInterfaceObj.networkInterfaceName);
 		setParameter(networkInterfaceObjStr + ".Description", networkInterfaceObj.description);
+		setParameter(networkInterfaceObjStr + ".QueueNumber", std::to_string(networkInterfaceObj.queueNumber));
 	}
 }

--- a/ecs/src/model/SendFileRequest.cc
+++ b/ecs/src/model/SendFileRequest.cc
@@ -0,0 +1,207 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/ecs/model/SendFileRequest.h>
+
+using AlibabaCloud::Ecs::Model::SendFileRequest;
+
+SendFileRequest::SendFileRequest() :
+	RpcServiceRequest("ecs", "2014-05-26", "SendFile")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+SendFileRequest::~SendFileRequest()
+{}
+
+long SendFileRequest::getResourceOwnerId()const
+{
+	return resourceOwnerId_;
+}
+
+void SendFileRequest::setResourceOwnerId(long resourceOwnerId)
+{
+	resourceOwnerId_ = resourceOwnerId;
+	setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
+}
+
+std::string SendFileRequest::getDescription()const
+{
+	return description_;
+}
+
+void SendFileRequest::setDescription(const std::string& description)
+{
+	description_ = description;
+	setParameter("Description", description);
+}
+
+long SendFileRequest::getTimeout()const
+{
+	return timeout_;
+}
+
+void SendFileRequest::setTimeout(long timeout)
+{
+	timeout_ = timeout;
+	setParameter("Timeout", std::to_string(timeout));
+}
+
+std::string SendFileRequest::getContent()const
+{
+	return content_;
+}
+
+void SendFileRequest::setContent(const std::string& content)
+{
+	content_ = content;
+	setParameter("Content", content);
+}
+
+std::string SendFileRequest::getRegionId()const
+{
+	return regionId_;
+}
+
+void SendFileRequest::setRegionId(const std::string& regionId)
+{
+	regionId_ = regionId;
+	setParameter("RegionId", regionId);
+}
+
+std::string SendFileRequest::getFileOwner()const
+{
+	return fileOwner_;
+}
+
+void SendFileRequest::setFileOwner(const std::string& fileOwner)
+{
+	fileOwner_ = fileOwner;
+	setParameter("FileOwner", fileOwner);
+}
+
+bool SendFileRequest::getOverwrite()const
+{
+	return overwrite_;
+}
+
+void SendFileRequest::setOverwrite(bool overwrite)
+{
+	overwrite_ = overwrite;
+	setParameter("Overwrite", overwrite ? "true" : "false");
+}
+
+std::string SendFileRequest::getResourceOwnerAccount()const
+{
+	return resourceOwnerAccount_;
+}
+
+void SendFileRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
+{
+	resourceOwnerAccount_ = resourceOwnerAccount;
+	setParameter("ResourceOwnerAccount", resourceOwnerAccount);
+}
+
+std::string SendFileRequest::getOwnerAccount()const
+{
+	return ownerAccount_;
+}
+
+void SendFileRequest::setOwnerAccount(const std::string& ownerAccount)
+{
+	ownerAccount_ = ownerAccount;
+	setParameter("OwnerAccount", ownerAccount);
+}
+
+std::string SendFileRequest::getFileMode()const
+{
+	return fileMode_;
+}
+
+void SendFileRequest::setFileMode(const std::string& fileMode)
+{
+	fileMode_ = fileMode;
+	setParameter("FileMode", fileMode);
+}
+
+long SendFileRequest::getOwnerId()const
+{
+	return ownerId_;
+}
+
+void SendFileRequest::setOwnerId(long ownerId)
+{
+	ownerId_ = ownerId;
+	setParameter("OwnerId", std::to_string(ownerId));
+}
+
+std::string SendFileRequest::getContentType()const
+{
+	return contentType_;
+}
+
+void SendFileRequest::setContentType(const std::string& contentType)
+{
+	contentType_ = contentType;
+	setParameter("ContentType", contentType);
+}
+
+std::vector<std::string> SendFileRequest::getInstanceId()const
+{
+	return instanceId_;
+}
+
+void SendFileRequest::setInstanceId(const std::vector<std::string>& instanceId)
+{
+	instanceId_ = instanceId;
+	for(int dep1 = 0; dep1!= instanceId.size(); dep1++) {
+		setParameter("InstanceId."+ std::to_string(dep1), instanceId.at(dep1));
+	}
+}
+
+std::string SendFileRequest::getName()const
+{
+	return name_;
+}
+
+void SendFileRequest::setName(const std::string& name)
+{
+	name_ = name;
+	setParameter("Name", name);
+}
+
+std::string SendFileRequest::getFileGroup()const
+{
+	return fileGroup_;
+}
+
+void SendFileRequest::setFileGroup(const std::string& fileGroup)
+{
+	fileGroup_ = fileGroup;
+	setParameter("FileGroup", fileGroup);
+}
+
+std::string SendFileRequest::getTargetDir()const
+{
+	return targetDir_;
+}
+
+void SendFileRequest::setTargetDir(const std::string& targetDir)
+{
+	targetDir_ = targetDir;
+	setParameter("TargetDir", targetDir);
+}
+
--- a/ecs/src/model/SendFileResult.cc
+++ b/ecs/src/model/SendFileResult.cc
@@ -0,0 +1,51 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/ecs/model/SendFileResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Ecs;
+using namespace AlibabaCloud::Ecs::Model;
+
+SendFileResult::SendFileResult() :
+	ServiceResult()
+{}
+
+SendFileResult::SendFileResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+SendFileResult::~SendFileResult()
+{}
+
+void SendFileResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	if(!value["InvokeId"].isNull())
+		invokeId_ = value["InvokeId"].asString();
+
+}
+
+std::string SendFileResult::getInvokeId()const
+{
+	return invokeId_;
+}
+