ListNodesByQueue and ListJobsWithFilters add Async.

ehpc/src/model/AddContainerAppRequest.cc

@@ -0,0 +1,81 @@
+/*
+ * 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/ehpc/model/AddContainerAppRequest.h>
+
+using AlibabaCloud::EHPC::Model::AddContainerAppRequest;
+
+AddContainerAppRequest::AddContainerAppRequest()
+    : RpcServiceRequest("ehpc", "2018-04-12", "AddContainerApp") {
+  setMethod(HttpRequest::Method::Get);
+}
+
+AddContainerAppRequest::~AddContainerAppRequest() {}
+
+std::string AddContainerAppRequest::getDescription() const {
+  return description_;
+}
+
+void AddContainerAppRequest::setDescription(const std::string &description) {
+  description_ = description;
+  setParameter(std::string("Description"), description);
+}
+
+std::string AddContainerAppRequest::getRepository() const {
+  return repository_;
+}
+
+void AddContainerAppRequest::setRepository(const std::string &repository) {
+  repository_ = repository;
+  setParameter(std::string("Repository"), repository);
+}
+
+std::string AddContainerAppRequest::getAccessKeyId() const {
+  return accessKeyId_;
+}
+
+void AddContainerAppRequest::setAccessKeyId(const std::string &accessKeyId) {
+  accessKeyId_ = accessKeyId;
+  setParameter(std::string("AccessKeyId"), accessKeyId);
+}
+
+std::string AddContainerAppRequest::getContainerType() const {
+  return containerType_;
+}
+
+void AddContainerAppRequest::setContainerType(const std::string &containerType) {
+  containerType_ = containerType;
+  setParameter(std::string("ContainerType"), containerType);
+}
+
+std::string AddContainerAppRequest::getName() const {
+  return name_;
+}
+
+void AddContainerAppRequest::setName(const std::string &name) {
+  name_ = name;
+  setParameter(std::string("Name"), name);
+}
+
+std::string AddContainerAppRequest::getImageTag() const {
+  return imageTag_;
+}
+
+void AddContainerAppRequest::setImageTag(const std::string &imageTag) {
+  imageTag_ = imageTag;
+  setParameter(std::string("ImageTag"), imageTag);
+}
+

ehpc/src/model/AddContainerAppResult.cc

@@ -0,0 +1,52 @@
+/*
+ * 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/ehpc/model/AddContainerAppResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::EHPC;
+using namespace AlibabaCloud::EHPC::Model;
+
+AddContainerAppResult::AddContainerAppResult() :
+	ServiceResult()
+{}
+
+AddContainerAppResult::AddContainerAppResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+AddContainerAppResult::~AddContainerAppResult()
+{}
+
+void AddContainerAppResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto allContainerId = value["ContainerId"]["ContainerId"];
+	for (const auto &item : allContainerId)
+		containerId_.push_back(item.asString());
+
+}
+
+std::vector<std::string> AddContainerAppResult::getContainerId()const
+{
+	return containerId_;
+}
+

ehpc/src/model/AddExistedNodesRequest.cc

@@ -0,0 +1,85 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/ehpc/model/AddExistedNodesRequest.h>
+
+using AlibabaCloud::EHPC::Model::AddExistedNodesRequest;
+
+AddExistedNodesRequest::AddExistedNodesRequest()
+    : RpcServiceRequest("ehpc", "2018-04-12", "AddExistedNodes") {
+  setMethod(HttpRequest::Method::Get);
+}
+
+AddExistedNodesRequest::~AddExistedNodesRequest() {}
+
+std::string AddExistedNodesRequest::getImageId() const {
+  return imageId_;
+}
+
+void AddExistedNodesRequest::setImageId(const std::string &imageId) {
+  imageId_ = imageId;
+  setParameter(std::string("ImageId"), imageId);
+}
+
+std::vector<AddExistedNodesRequest::Instance> AddExistedNodesRequest::getInstance() const {
+  return instance_;
+}
+
+void AddExistedNodesRequest::setInstance(const std::vector<AddExistedNodesRequest::Instance> &instance) {
+  instance_ = instance;
+  for(int dep1 = 0; dep1 != instance.size(); dep1++) {
+  auto instanceObj = instance.at(dep1);
+  std::string instanceObjStr = std::string("Instance") + "." + std::to_string(dep1 + 1);
+    setParameter(instanceObjStr + ".Id", instanceObj.id);
+  }
+}
+
+std::string AddExistedNodesRequest::getClusterId() const {
+  return clusterId_;
+}
+
+void AddExistedNodesRequest::setClusterId(const std::string &clusterId) {
+  clusterId_ = clusterId;
+  setParameter(std::string("ClusterId"), clusterId);
+}
+
+std::string AddExistedNodesRequest::getJobQueue() const {
+  return jobQueue_;
+}
+
+void AddExistedNodesRequest::setJobQueue(const std::string &jobQueue) {
+  jobQueue_ = jobQueue;
+  setParameter(std::string("JobQueue"), jobQueue);
+}
+
+std::string AddExistedNodesRequest::getAccessKeyId() const {
+  return accessKeyId_;
+}
+
+void AddExistedNodesRequest::setAccessKeyId(const std::string &accessKeyId) {
+  accessKeyId_ = accessKeyId;
+  setParameter(std::string("AccessKeyId"), accessKeyId);
+}
+
+std::string AddExistedNodesRequest::getImageOwnerAlias() const {
+  return imageOwnerAlias_;
+}
+
+void AddExistedNodesRequest::setImageOwnerAlias(const std::string &imageOwnerAlias) {
+  imageOwnerAlias_ = imageOwnerAlias;
+  setParameter(std::string("ImageOwnerAlias"), imageOwnerAlias);
+}
+

ehpc/src/model/AddExistedNodesResult.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/ehpc/model/AddExistedNodesResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::EHPC;
+using namespace AlibabaCloud::EHPC::Model;
+
+AddExistedNodesResult::AddExistedNodesResult() :
+	ServiceResult()
+{}
+
+AddExistedNodesResult::AddExistedNodesResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+AddExistedNodesResult::~AddExistedNodesResult()
+{}
+
+void AddExistedNodesResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	if(!value["TaskId"].isNull())
+		taskId_ = value["TaskId"].asString();
+
+}
+
+std::string AddExistedNodesResult::getTaskId()const
+{
+	return taskId_;
+}
+

ehpc/src/model/AddLocalNodesRequest.cc

@@ -0,0 +1,63 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/ehpc/model/AddLocalNodesRequest.h>
+
+using AlibabaCloud::EHPC::Model::AddLocalNodesRequest;
+
+AddLocalNodesRequest::AddLocalNodesRequest()
+    : RpcServiceRequest("ehpc", "2018-04-12", "AddLocalNodes") {
+  setMethod(HttpRequest::Method::Get);
+}
+
+AddLocalNodesRequest::~AddLocalNodesRequest() {}
+
+std::string AddLocalNodesRequest::getClusterId() const {
+  return clusterId_;
+}
+
+void AddLocalNodesRequest::setClusterId(const std::string &clusterId) {
+  clusterId_ = clusterId;
+  setParameter(std::string("ClusterId"), clusterId);
+}
+
+std::string AddLocalNodesRequest::getAccessKeyId() const {
+  return accessKeyId_;
+}
+
+void AddLocalNodesRequest::setAccessKeyId(const std::string &accessKeyId) {
+  accessKeyId_ = accessKeyId;
+  setParameter(std::string("AccessKeyId"), accessKeyId);
+}
+
+std::string AddLocalNodesRequest::getNodes() const {
+  return nodes_;
+}
+
+void AddLocalNodesRequest::setNodes(const std::string &nodes) {
+  nodes_ = nodes;
+  setParameter(std::string("Nodes"), nodes);
+}
+
+std::string AddLocalNodesRequest::getQueue() const {
+  return queue_;
+}
+
+void AddLocalNodesRequest::setQueue(const std::string &queue) {
+  queue_ = queue;
+  setParameter(std::string("Queue"), queue);
+}
+

ehpc/src/model/AddLocalNodesResult.cc

@@ -0,0 +1,52 @@
+/*
+ * 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/ehpc/model/AddLocalNodesResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::EHPC;
+using namespace AlibabaCloud::EHPC::Model;
+
+AddLocalNodesResult::AddLocalNodesResult() :
+	ServiceResult()
+{}
+
+AddLocalNodesResult::AddLocalNodesResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+AddLocalNodesResult::~AddLocalNodesResult()
+{}
+
+void AddLocalNodesResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto allInstanceIds = value["InstanceIds"]["InstanceId"];
+	for (const auto &item : allInstanceIds)
+		instanceIds_.push_back(item.asString());
+
+}
+
+std::vector<std::string> AddLocalNodesResult::getInstanceIds()const
+{
+	return instanceIds_;
+}
+

ehpc/src/model/AddNodesRequest.cc

@@ -19,7 +19,7 @@
 using AlibabaCloud::EHPC::Model::AddNodesRequest;
 
 AddNodesRequest::AddNodesRequest()
-    : RpcServiceRequest("ehpc", "2017-07-14", "AddNodes") {
+    : RpcServiceRequest("ehpc", "2018-04-12", "AddNodes") {
   setMethod(HttpRequest::Method::Get);
 }
 
@@ -34,6 +34,159 @@ void AddNodesRequest::setImageId(const std::string &imageId) {
   setParameter(std::string("ImageId"), imageId);
 }
 
+std::string AddNodesRequest::getSystemDiskLevel() const {
+  return systemDiskLevel_;
+}
+
+void AddNodesRequest::setSystemDiskLevel(const std::string &systemDiskLevel) {
+  systemDiskLevel_ = systemDiskLevel;
+  setParameter(std::string("SystemDiskLevel"), systemDiskLevel);
+}
+
+std::string AddNodesRequest::getClientToken() const {
+  return clientToken_;
+}
+
+void AddNodesRequest::setClientToken(const std::string &clientToken) {
+  clientToken_ = clientToken;
+  setParameter(std::string("ClientToken"), clientToken);
+}
+
+bool AddNodesRequest::getAllocatePublicAddress() const {
+  return allocatePublicAddress_;
+}
+
+void AddNodesRequest::setAllocatePublicAddress(bool allocatePublicAddress) {
+  allocatePublicAddress_ = allocatePublicAddress;
+  setParameter(std::string("AllocatePublicAddress"), allocatePublicAddress ? "true" : "false");
+}
+
+int AddNodesRequest::getInternetMaxBandWidthOut() const {
+  return internetMaxBandWidthOut_;
+}
+
+void AddNodesRequest::setInternetMaxBandWidthOut(int internetMaxBandWidthOut) {
+  internetMaxBandWidthOut_ = internetMaxBandWidthOut;
+  setParameter(std::string("InternetMaxBandWidthOut"), std::to_string(internetMaxBandWidthOut));
+}
+
+std::string AddNodesRequest::getJobQueue() const {
+  return jobQueue_;
+}
+
+void AddNodesRequest::setJobQueue(const std::string &jobQueue) {
+  jobQueue_ = jobQueue;
+  setParameter(std::string("JobQueue"), jobQueue);
+}
+
+std::string AddNodesRequest::getAccessKeyId() const {
+  return accessKeyId_;
+}
+
+void AddNodesRequest::setAccessKeyId(const std::string &accessKeyId) {
+  accessKeyId_ = accessKeyId;
+  setParameter(std::string("AccessKeyId"), accessKeyId);
+}
+
+std::string AddNodesRequest::getImageOwnerAlias() const {
+  return imageOwnerAlias_;
+}
+
+void AddNodesRequest::setImageOwnerAlias(const std::string &imageOwnerAlias) {
+  imageOwnerAlias_ = imageOwnerAlias;
+  setParameter(std::string("ImageOwnerAlias"), imageOwnerAlias);
+}
+
+std::string AddNodesRequest::getSystemDiskType() const {
+  return systemDiskType_;
+}
+
+void AddNodesRequest::setSystemDiskType(const std::string &systemDiskType) {
+  systemDiskType_ = systemDiskType;
+  setParameter(std::string("SystemDiskType"), systemDiskType);
+}
+
+std::vector<AddNodesRequest::DataDisks> AddNodesRequest::getDataDisks() const {
+  return dataDisks_;
+}
+
+void AddNodesRequest::setDataDisks(const std::vector<AddNodesRequest::DataDisks> &dataDisks) {
+  dataDisks_ = dataDisks;
+  for(int dep1 = 0; dep1 != dataDisks.size(); dep1++) {
+  auto dataDisksObj = dataDisks.at(dep1);
+  std::string dataDisksObjStr = std::string("DataDisks") + "." + std::to_string(dep1 + 1);
+    setParameter(dataDisksObjStr + ".DataDiskDeleteWithInstance", dataDisksObj.dataDiskDeleteWithInstance ? "true" : "false");
+    setParameter(dataDisksObjStr + ".DataDiskEncrypted", dataDisksObj.dataDiskEncrypted ? "true" : "false");
+    setParameter(dataDisksObjStr + ".DataDiskKMSKeyId", dataDisksObj.dataDiskKMSKeyId);
+    setParameter(dataDisksObjStr + ".DataDiskSize", std::to_string(dataDisksObj.dataDiskSize));
+    setParameter(dataDisksObjStr + ".DataDiskCategory", dataDisksObj.dataDiskCategory);
+    setParameter(dataDisksObjStr + ".DataDiskPerformanceLevel", dataDisksObj.dataDiskPerformanceLevel);
+  }
+}
+
+int AddNodesRequest::getMinCount() const {
+  return minCount_;
+}
+
+void AddNodesRequest::setMinCount(int minCount) {
+  minCount_ = minCount;
+  setParameter(std::string("MinCount"), std::to_string(minCount));
+}
+
+int AddNodesRequest::getSystemDiskSize() const {
+  return systemDiskSize_;
+}
+
+void AddNodesRequest::setSystemDiskSize(int systemDiskSize) {
+  systemDiskSize_ = systemDiskSize;
+  setParameter(std::string("SystemDiskSize"), std::to_string(systemDiskSize));
+}
+
+std::string AddNodesRequest::getInstanceType() const {
+  return instanceType_;
+}
+
+void AddNodesRequest::setInstanceType(const std::string &instanceType) {
+  instanceType_ = instanceType;
+  setParameter(std::string("InstanceType"), instanceType);
+}
+
+std::string AddNodesRequest::getHostNamePrefix() const {
+  return hostNamePrefix_;
+}
+
+void AddNodesRequest::setHostNamePrefix(const std::string &hostNamePrefix) {
+  hostNamePrefix_ = hostNamePrefix;
+  setParameter(std::string("HostNamePrefix"), hostNamePrefix);
+}
+
+std::string AddNodesRequest::getComputeSpotPriceLimit() const {
+  return computeSpotPriceLimit_;
+}
+
+void AddNodesRequest::setComputeSpotPriceLimit(const std::string &computeSpotPriceLimit) {
+  computeSpotPriceLimit_ = computeSpotPriceLimit;
+  setParameter(std::string("ComputeSpotPriceLimit"), computeSpotPriceLimit);
+}
+
+int AddNodesRequest::getAutoRenewPeriod() const {
+  return autoRenewPeriod_;
+}
+
+void AddNodesRequest::setAutoRenewPeriod(int autoRenewPeriod) {
+  autoRenewPeriod_ = autoRenewPeriod;
+  setParameter(std::string("AutoRenewPeriod"), std::to_string(autoRenewPeriod));
+}
+
+int AddNodesRequest::getPeriod() const {
+  return period_;
+}
+
+void AddNodesRequest::setPeriod(int period) {
+  period_ = period;
+  setParameter(std::string("Period"), std::to_string(period));
+}
+
 int AddNodesRequest::getCount() const {
   return count_;
 }
@@ -61,30 +214,102 @@ void AddNodesRequest::setComputeSpotStrategy(const std::string &computeSpotStrat
   setParameter(std::string("ComputeSpotStrategy"), computeSpotStrategy);
 }
 
-std::string AddNodesRequest::getAccessKeyId() const {
-  return accessKeyId_;
+std::string AddNodesRequest::getHostNameSuffix() const {
+  return hostNameSuffix_;
 }
 
-void AddNodesRequest::setAccessKeyId(const std::string &accessKeyId) {
-  accessKeyId_ = accessKeyId;
-  setParameter(std::string("AccessKeyId"), accessKeyId);
+void AddNodesRequest::setHostNameSuffix(const std::string &hostNameSuffix) {
+  hostNameSuffix_ = hostNameSuffix;
+  setParameter(std::string("HostNameSuffix"), hostNameSuffix);
 }
 
-std::string AddNodesRequest::getImageOwnerAlias() const {
-  return imageOwnerAlias_;
+bool AddNodesRequest::getSync() const {
+  return sync_;
 }
 
-void AddNodesRequest::setImageOwnerAlias(const std::string &imageOwnerAlias) {
-  imageOwnerAlias_ = imageOwnerAlias;
-  setParameter(std::string("ImageOwnerAlias"), imageOwnerAlias);
+void AddNodesRequest::setSync(bool sync) {
+  sync_ = sync;
+  setParameter(std::string("Sync"), sync ? "true" : "false");
 }
 
-std::string AddNodesRequest::getComputeSpotPriceLimit() const {
-  return computeSpotPriceLimit_;
+std::string AddNodesRequest::getVSwitchId() const {
+  return vSwitchId_;
 }
 
-void AddNodesRequest::setComputeSpotPriceLimit(const std::string &computeSpotPriceLimit) {
-  computeSpotPriceLimit_ = computeSpotPriceLimit;
-  setParameter(std::string("ComputeSpotPriceLimit"), computeSpotPriceLimit);
+void AddNodesRequest::setVSwitchId(const std::string &vSwitchId) {
+  vSwitchId_ = vSwitchId;
+  setParameter(std::string("VSwitchId"), vSwitchId);
+}
+
+std::string AddNodesRequest::getPeriodUnit() const {
+  return periodUnit_;
+}
+
+void AddNodesRequest::setPeriodUnit(const std::string &periodUnit) {
+  periodUnit_ = periodUnit;
+  setParameter(std::string("PeriodUnit"), periodUnit);
+}
+
+bool AddNodesRequest::getComputeEnableHt() const {
+  return computeEnableHt_;
+}
+
+void AddNodesRequest::setComputeEnableHt(bool computeEnableHt) {
+  computeEnableHt_ = computeEnableHt;
+  setParameter(std::string("ComputeEnableHt"), computeEnableHt ? "true" : "false");
+}
+
+std::string AddNodesRequest::getAutoRenew() const {
+  return autoRenew_;
+}
+
+void AddNodesRequest::setAutoRenew(const std::string &autoRenew) {
+  autoRenew_ = autoRenew;
+  setParameter(std::string("AutoRenew"), autoRenew);
+}
+
+std::string AddNodesRequest::getEcsChargeType() const {
+  return ecsChargeType_;
+}
+
+void AddNodesRequest::setEcsChargeType(const std::string &ecsChargeType) {
+  ecsChargeType_ = ecsChargeType;
+  setParameter(std::string("EcsChargeType"), ecsChargeType);
+}
+
+std::string AddNodesRequest::getInternetChargeType() const {
+  return internetChargeType_;
+}
+
+void AddNodesRequest::setInternetChargeType(const std::string &internetChargeType) {
+  internetChargeType_ = internetChargeType;
+  setParameter(std::string("InternetChargeType"), internetChargeType);
+}
+
+std::string AddNodesRequest::getCreateMode() const {
+  return createMode_;
+}
+
+void AddNodesRequest::setCreateMode(const std::string &createMode) {
+  createMode_ = createMode;
+  setParameter(std::string("CreateMode"), createMode);
+}
+
+std::string AddNodesRequest::getZoneId() const {
+  return zoneId_;
+}
+
+void AddNodesRequest::setZoneId(const std::string &zoneId) {
+  zoneId_ = zoneId;
+  setParameter(std::string("ZoneId"), zoneId);
+}
+
+int AddNodesRequest::getInternetMaxBandWidthIn() const {
+  return internetMaxBandWidthIn_;
+}
+
+void AddNodesRequest::setInternetMaxBandWidthIn(int internetMaxBandWidthIn) {
+  internetMaxBandWidthIn_ = internetMaxBandWidthIn;
+  setParameter(std::string("InternetMaxBandWidthIn"), std::to_string(internetMaxBandWidthIn));
 }
 

ehpc/src/model/AddNodesResult.cc

@@ -42,9 +42,16 @@ void AddNodesResult::parse(const std::string &payload)
 	auto allInstanceIds = value["InstanceIds"]["InstanceId"];
 	for (const auto &item : allInstanceIds)
 		instanceIds_.push_back(item.asString());
+	if(!value["TaskId"].isNull())
+		taskId_ = value["TaskId"].asString();
 
 }
 
+std::string AddNodesResult::getTaskId()const
+{
+	return taskId_;
+}
+
 std::vector<std::string> AddNodesResult::getInstanceIds()const
 {
 	return instanceIds_;

ehpc/src/model/AddQueueRequest.cc

@@ -0,0 +1,54 @@
+/*
+ * 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/ehpc/model/AddQueueRequest.h>
+
+using AlibabaCloud::EHPC::Model::AddQueueRequest;
+
+AddQueueRequest::AddQueueRequest()
+    : RpcServiceRequest("ehpc", "2018-04-12", "AddQueue") {
+  setMethod(HttpRequest::Method::Get);
+}
+
+AddQueueRequest::~AddQueueRequest() {}
+
+std::string AddQueueRequest::getQueueName() const {
+  return queueName_;
+}
+
+void AddQueueRequest::setQueueName(const std::string &queueName) {
+  queueName_ = queueName;
+  setParameter(std::string("QueueName"), queueName);
+}
+
+std::string AddQueueRequest::getClusterId() const {
+  return clusterId_;
+}
+
+void AddQueueRequest::setClusterId(const std::string &clusterId) {
+  clusterId_ = clusterId;
+  setParameter(std::string("ClusterId"), clusterId);
+}
+
+std::string AddQueueRequest::getAccessKeyId() const {
+  return accessKeyId_;
+}
+
+void AddQueueRequest::setAccessKeyId(const std::string &accessKeyId) {
+  accessKeyId_ = accessKeyId;
+  setParameter(std::string("AccessKeyId"), accessKeyId);
+}
+

ehpc/src/model/AddQueueResult.cc

@@ -14,26 +14,26 @@
  * limitations under the License.
  */
 
-#include <alibabacloud/ehpc/model/SetJobUserResult.h>
+#include <alibabacloud/ehpc/model/AddQueueResult.h>
 #include <json/json.h>
 
 using namespace AlibabaCloud::EHPC;
 using namespace AlibabaCloud::EHPC::Model;
 
-SetJobUserResult::SetJobUserResult() :
+AddQueueResult::AddQueueResult() :
 	ServiceResult()
 {}
 
-SetJobUserResult::SetJobUserResult(const std::string &payload) :
+AddQueueResult::AddQueueResult(const std::string &payload) :
 	ServiceResult()
 {
 	parse(payload);
 }
 
-SetJobUserResult::~SetJobUserResult()
+AddQueueResult::~AddQueueResult()
 {}
 
-void SetJobUserResult::parse(const std::string &payload)
+void AddQueueResult::parse(const std::string &payload)
 {
 	Json::Reader reader;
 	Json::Value value;

ehpc/src/model/AddSecurityGroupRequest.cc

@@ -0,0 +1,63 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/ehpc/model/AddSecurityGroupRequest.h>
+
+using AlibabaCloud::EHPC::Model::AddSecurityGroupRequest;
+
+AddSecurityGroupRequest::AddSecurityGroupRequest()
+    : RpcServiceRequest("ehpc", "2018-04-12", "AddSecurityGroup") {
+  setMethod(HttpRequest::Method::Get);
+}
+
+AddSecurityGroupRequest::~AddSecurityGroupRequest() {}
+
+std::string AddSecurityGroupRequest::getClientToken() const {
+  return clientToken_;
+}
+
+void AddSecurityGroupRequest::setClientToken(const std::string &clientToken) {
+  clientToken_ = clientToken;
+  setParameter(std::string("ClientToken"), clientToken);
+}
+
+std::string AddSecurityGroupRequest::getSecurityGroupId() const {
+  return securityGroupId_;
+}
+
+void AddSecurityGroupRequest::setSecurityGroupId(const std::string &securityGroupId) {
+  securityGroupId_ = securityGroupId;
+  setParameter(std::string("SecurityGroupId"), securityGroupId);
+}
+
+std::string AddSecurityGroupRequest::getClusterId() const {
+  return clusterId_;
+}
+
+void AddSecurityGroupRequest::setClusterId(const std::string &clusterId) {
+  clusterId_ = clusterId;
+  setParameter(std::string("ClusterId"), clusterId);
+}
+
+std::string AddSecurityGroupRequest::getAccessKeyId() const {
+  return accessKeyId_;
+}
+
+void AddSecurityGroupRequest::setAccessKeyId(const std::string &accessKeyId) {
+  accessKeyId_ = accessKeyId;
+  setParameter(std::string("AccessKeyId"), accessKeyId);
+}
+

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

ehpc/src/model/AddUsersRequest.cc

@@ -19,7 +19,7 @@
 using AlibabaCloud::EHPC::Model::AddUsersRequest;
 
 AddUsersRequest::AddUsersRequest()
-    : RpcServiceRequest("ehpc", "2017-07-14", "AddUsers") {
+    : RpcServiceRequest("ehpc", "2018-04-12", "AddUsers") {
   setMethod(HttpRequest::Method::Get);
 }
 
@@ -43,15 +43,6 @@ void AddUsersRequest::setAccessKeyId(const std::string &accessKeyId) {
   setParameter(std::string("AccessKeyId"), accessKeyId);
 }
 
-bool AddUsersRequest::getReleaseInstance() const {
-  return releaseInstance_;
-}
-
-void AddUsersRequest::setReleaseInstance(bool releaseInstance) {
-  releaseInstance_ = releaseInstance;
-  setParameter(std::string("ReleaseInstance"), releaseInstance ? "true" : "false");
-}
-
 std::vector<AddUsersRequest::User> AddUsersRequest::getUser() const {
   return user_;
 }

ehpc/src/model/ApplyNodesRequest.cc

@@ -0,0 +1,295 @@
+/*
+ * 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/ehpc/model/ApplyNodesRequest.h>
+
+using AlibabaCloud::EHPC::Model::ApplyNodesRequest;
+
+ApplyNodesRequest::ApplyNodesRequest()
+    : RpcServiceRequest("ehpc", "2018-04-12", "ApplyNodes") {
+  setMethod(HttpRequest::Method::Get);
+}
+
+ApplyNodesRequest::~ApplyNodesRequest() {}
+
+std::string ApplyNodesRequest::getImageId() const {
+  return imageId_;
+}
+
+void ApplyNodesRequest::setImageId(const std::string &imageId) {
+  imageId_ = imageId;
+  setParameter(std::string("ImageId"), imageId);
+}
+
+int ApplyNodesRequest::getMemory() const {
+  return memory_;
+}
+
+void ApplyNodesRequest::setMemory(int memory) {
+  memory_ = memory;
+  setParameter(std::string("Memory"), std::to_string(memory));
+}
+
+std::string ApplyNodesRequest::getSystemDiskLevel() const {
+  return systemDiskLevel_;
+}
+
+void ApplyNodesRequest::setSystemDiskLevel(const std::string &systemDiskLevel) {
+  systemDiskLevel_ = systemDiskLevel;
+  setParameter(std::string("SystemDiskLevel"), systemDiskLevel);
+}
+
+bool ApplyNodesRequest::getAllocatePublicAddress() const {
+  return allocatePublicAddress_;
+}
+
+void ApplyNodesRequest::setAllocatePublicAddress(bool allocatePublicAddress) {
+  allocatePublicAddress_ = allocatePublicAddress;
+  setParameter(std::string("AllocatePublicAddress"), allocatePublicAddress ? "true" : "false");
+}
+
+int ApplyNodesRequest::getInternetMaxBandWidthOut() const {
+  return internetMaxBandWidthOut_;
+}
+
+void ApplyNodesRequest::setInternetMaxBandWidthOut(int internetMaxBandWidthOut) {
+  internetMaxBandWidthOut_ = internetMaxBandWidthOut;
+  setParameter(std::string("InternetMaxBandWidthOut"), std::to_string(internetMaxBandWidthOut));
+}
+
+std::string ApplyNodesRequest::getResourceAmountType() const {
+  return resourceAmountType_;
+}
+
+void ApplyNodesRequest::setResourceAmountType(const std::string &resourceAmountType) {
+  resourceAmountType_ = resourceAmountType;
+  setParameter(std::string("ResourceAmountType"), resourceAmountType);
+}
+
+bool ApplyNodesRequest::getStrictResourceProvision() const {
+  return strictResourceProvision_;
+}
+
+void ApplyNodesRequest::setStrictResourceProvision(bool strictResourceProvision) {
+  strictResourceProvision_ = strictResourceProvision;
+  setParameter(std::string("StrictResourceProvision"), strictResourceProvision ? "true" : "false");
+}
+
+std::string ApplyNodesRequest::getJobQueue() const {
+  return jobQueue_;
+}
+
+void ApplyNodesRequest::setJobQueue(const std::string &jobQueue) {
+  jobQueue_ = jobQueue;
+  setParameter(std::string("JobQueue"), jobQueue);
+}
+
+std::string ApplyNodesRequest::getAccessKeyId() const {
+  return accessKeyId_;
+}
+
+void ApplyNodesRequest::setAccessKeyId(const std::string &accessKeyId) {
+  accessKeyId_ = accessKeyId;
+  setParameter(std::string("AccessKeyId"), accessKeyId);
+}
+
+std::string ApplyNodesRequest::getSystemDiskType() const {
+  return systemDiskType_;
+}
+
+void ApplyNodesRequest::setSystemDiskType(const std::string &systemDiskType) {
+  systemDiskType_ = systemDiskType;
+  setParameter(std::string("SystemDiskType"), systemDiskType);
+}
+
+int ApplyNodesRequest::getCores() const {
+  return cores_;
+}
+
+void ApplyNodesRequest::setCores(int cores) {
+  cores_ = cores;
+  setParameter(std::string("Cores"), std::to_string(cores));
+}
+
+int ApplyNodesRequest::getSystemDiskSize() const {
+  return systemDiskSize_;
+}
+
+void ApplyNodesRequest::setSystemDiskSize(int systemDiskSize) {
+  systemDiskSize_ = systemDiskSize;
+  setParameter(std::string("SystemDiskSize"), std::to_string(systemDiskSize));
+}
+
+std::vector<ApplyNodesRequest::ZoneInfos> ApplyNodesRequest::getZoneInfos() const {
+  return zoneInfos_;
+}
+
+void ApplyNodesRequest::setZoneInfos(const std::vector<ApplyNodesRequest::ZoneInfos> &zoneInfos) {
+  zoneInfos_ = zoneInfos;
+  for(int dep1 = 0; dep1 != zoneInfos.size(); dep1++) {
+  auto zoneInfosObj = zoneInfos.at(dep1);
+  std::string zoneInfosObjStr = std::string("ZoneInfos") + "." + std::to_string(dep1 + 1);
+    setParameter(zoneInfosObjStr + ".VSwitchId", zoneInfosObj.vSwitchId);
+    setParameter(zoneInfosObjStr + ".ZoneId", zoneInfosObj.zoneId);
+  }
+}
+
+std::string ApplyNodesRequest::getHostNamePrefix() const {
+  return hostNamePrefix_;
+}
+
+void ApplyNodesRequest::setHostNamePrefix(const std::string &hostNamePrefix) {
+  hostNamePrefix_ = hostNamePrefix;
+  setParameter(std::string("HostNamePrefix"), hostNamePrefix);
+}
+
+std::vector<ApplyNodesRequest::Tag> ApplyNodesRequest::getTag() const {
+  return tag_;
+}
+
+void ApplyNodesRequest::setTag(const std::vector<ApplyNodesRequest::Tag> &tag) {
+  tag_ = tag;
+  for(int dep1 = 0; dep1 != tag.size(); dep1++) {
+  auto tagObj = tag.at(dep1);
+  std::string tagObjStr = std::string("Tag") + "." + std::to_string(dep1 + 1);
+    setParameter(tagObjStr + ".Value", tagObj.value);
+    setParameter(tagObjStr + ".Key", tagObj.key);
+  }
+}
+
+float ApplyNodesRequest::getComputeSpotPriceLimit() const {
+  return computeSpotPriceLimit_;
+}
+
+void ApplyNodesRequest::setComputeSpotPriceLimit(float computeSpotPriceLimit) {
+  computeSpotPriceLimit_ = computeSpotPriceLimit;
+  setParameter(std::string("ComputeSpotPriceLimit"), std::to_string(computeSpotPriceLimit));
+}
+
+std::string ApplyNodesRequest::getClusterId() const {
+  return clusterId_;
+}
+
+void ApplyNodesRequest::setClusterId(const std::string &clusterId) {
+  clusterId_ = clusterId;
+  setParameter(std::string("ClusterId"), clusterId);
+}
+
+std::string ApplyNodesRequest::getComputeSpotStrategy() const {
+  return computeSpotStrategy_;
+}
+
+void ApplyNodesRequest::setComputeSpotStrategy(const std::string &computeSpotStrategy) {
+  computeSpotStrategy_ = computeSpotStrategy;
+  setParameter(std::string("ComputeSpotStrategy"), computeSpotStrategy);
+}
+
+std::string ApplyNodesRequest::getHostNameSuffix() const {
+  return hostNameSuffix_;
+}
+
+void ApplyNodesRequest::setHostNameSuffix(const std::string &hostNameSuffix) {
+  hostNameSuffix_ = hostNameSuffix;
+  setParameter(std::string("HostNameSuffix"), hostNameSuffix);
+}
+
+std::string ApplyNodesRequest::getPriorityStrategy() const {
+  return priorityStrategy_;
+}
+
+void ApplyNodesRequest::setPriorityStrategy(const std::string &priorityStrategy) {
+  priorityStrategy_ = priorityStrategy;
+  setParameter(std::string("PriorityStrategy"), priorityStrategy);
+}
+
+std::string ApplyNodesRequest::getInstanceFamilyLevel() const {
+  return instanceFamilyLevel_;
+}
+
+void ApplyNodesRequest::setInstanceFamilyLevel(const std::string &instanceFamilyLevel) {
+  instanceFamilyLevel_ = instanceFamilyLevel;
+  setParameter(std::string("InstanceFamilyLevel"), instanceFamilyLevel);
+}
+
+int ApplyNodesRequest::getRound() const {
+  return round_;
+}
+
+void ApplyNodesRequest::setRound(int round) {
+  round_ = round;
+  setParameter(std::string("Round"), std::to_string(round));
+}
+
+std::string ApplyNodesRequest::getInternetChargeType() const {
+  return internetChargeType_;
+}
+
+void ApplyNodesRequest::setInternetChargeType(const std::string &internetChargeType) {
+  internetChargeType_ = internetChargeType;
+  setParameter(std::string("InternetChargeType"), internetChargeType);
+}
+
+int ApplyNodesRequest::getInterval() const {
+  return interval_;
+}
+
+void ApplyNodesRequest::setInterval(int interval) {
+  interval_ = interval;
+  setParameter(std::string("Interval"), std::to_string(interval));
+}
+
+std::vector<ApplyNodesRequest::InstanceTypeModel> ApplyNodesRequest::getInstanceTypeModel() const {
+  return instanceTypeModel_;
+}
+
+void ApplyNodesRequest::setInstanceTypeModel(const std::vector<ApplyNodesRequest::InstanceTypeModel> &instanceTypeModel) {
+  instanceTypeModel_ = instanceTypeModel;
+  for(int dep1 = 0; dep1 != instanceTypeModel.size(); dep1++) {
+  auto instanceTypeModelObj = instanceTypeModel.at(dep1);
+  std::string instanceTypeModelObjStr = std::string("InstanceTypeModel") + "." + std::to_string(dep1 + 1);
+    setParameter(instanceTypeModelObjStr + ".MaxPrice", std::to_string(instanceTypeModelObj.maxPrice));
+    setParameter(instanceTypeModelObjStr + ".TargetImageId", instanceTypeModelObj.targetImageId);
+    setParameter(instanceTypeModelObjStr + ".InstanceType", instanceTypeModelObj.instanceType);
+  }
+}
+
+int ApplyNodesRequest::getInternetMaxBandWidthIn() const {
+  return internetMaxBandWidthIn_;
+}
+
+void ApplyNodesRequest::setInternetMaxBandWidthIn(int internetMaxBandWidthIn) {
+  internetMaxBandWidthIn_ = internetMaxBandWidthIn;
+  setParameter(std::string("InternetMaxBandWidthIn"), std::to_string(internetMaxBandWidthIn));
+}
+
+int ApplyNodesRequest::getTargetCapacity() const {
+  return targetCapacity_;
+}
+
+void ApplyNodesRequest::setTargetCapacity(int targetCapacity) {
+  targetCapacity_ = targetCapacity;
+  setParameter(std::string("TargetCapacity"), std::to_string(targetCapacity));
+}
+
+bool ApplyNodesRequest::getStrictSatisfiedTargetCapacity() const {
+  return strictSatisfiedTargetCapacity_;
+}
+
+void ApplyNodesRequest::setStrictSatisfiedTargetCapacity(bool strictSatisfiedTargetCapacity) {
+  strictSatisfiedTargetCapacity_ = strictSatisfiedTargetCapacity;
+  setParameter(std::string("StrictSatisfiedTargetCapacity"), strictSatisfiedTargetCapacity ? "true" : "false");
+}
+

ehpc/src/model/ApplyNodesResult.cc

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

ehpc/src/model/CreateClusterRequest.cc

@@ -19,12 +19,308 @@
 using AlibabaCloud::EHPC::Model::CreateClusterRequest;
 
 CreateClusterRequest::CreateClusterRequest()
-    : RpcServiceRequest("ehpc", "2017-07-14", "CreateCluster") {
+    : RpcServiceRequest("ehpc", "2018-04-12", "CreateCluster") {
   setMethod(HttpRequest::Method::Get);
 }
 
 CreateClusterRequest::~CreateClusterRequest() {}
 
+std::vector<CreateClusterRequest::AdditionalVolumes> CreateClusterRequest::getAdditionalVolumes() const {
+  return additionalVolumes_;
+}
+
+void CreateClusterRequest::setAdditionalVolumes(const std::vector<CreateClusterRequest::AdditionalVolumes> &additionalVolumes) {
+  additionalVolumes_ = additionalVolumes;
+  for(int dep1 = 0; dep1 != additionalVolumes.size(); dep1++) {
+  auto additionalVolumesObj = additionalVolumes.at(dep1);
+  std::string additionalVolumesObjStr = std::string("AdditionalVolumes") + "." + std::to_string(dep1 + 1);
+    setParameter(additionalVolumesObjStr + ".VolumeType", additionalVolumesObj.volumeType);
+    setParameter(additionalVolumesObjStr + ".VolumeMountOption", additionalVolumesObj.volumeMountOption);
+    setParameter(additionalVolumesObjStr + ".VolumeProtocol", additionalVolumesObj.volumeProtocol);
+    setParameter(additionalVolumesObjStr + ".LocalDirectory", additionalVolumesObj.localDirectory);
+    setParameter(additionalVolumesObjStr + ".RemoteDirectory", additionalVolumesObj.remoteDirectory);
+    for(int dep2 = 0; dep2 != additionalVolumesObj.roles.size(); dep2++) {
+    auto rolesObj = additionalVolumesObj.roles.at(dep2);
+    std::string rolesObjStr = additionalVolumesObjStr + ".Roles" + "." + std::to_string(dep2 + 1);
+      setParameter(rolesObjStr + ".Name", rolesObj.name);
+    }
+    setParameter(additionalVolumesObjStr + ".VolumeId", additionalVolumesObj.volumeId);
+    setParameter(additionalVolumesObjStr + ".VolumeMountpoint", additionalVolumesObj.volumeMountpoint);
+    setParameter(additionalVolumesObjStr + ".Location", additionalVolumesObj.location);
+    setParameter(additionalVolumesObjStr + ".JobQueue", additionalVolumesObj.jobQueue);
+  }
+}
+
+std::string CreateClusterRequest::getEcsOrderManagerInstanceType() const {
+  return ecsOrderManagerInstanceType_;
+}
+
+void CreateClusterRequest::setEcsOrderManagerInstanceType(const std::string &ecsOrderManagerInstanceType) {
+  ecsOrderManagerInstanceType_ = ecsOrderManagerInstanceType;
+  setParameter(std::string("EcsOrder.Manager.InstanceType"), ecsOrderManagerInstanceType);
+}
+
+std::string CreateClusterRequest::getKeyPairName() const {
+  return keyPairName_;
+}
+
+void CreateClusterRequest::setKeyPairName(const std::string &keyPairName) {
+  keyPairName_ = keyPairName;
+  setParameter(std::string("KeyPairName"), keyPairName);
+}
+
+std::string CreateClusterRequest::getSecurityGroupName() const {
+  return securityGroupName_;
+}
+
+void CreateClusterRequest::setSecurityGroupName(const std::string &securityGroupName) {
+  securityGroupName_ = securityGroupName;
+  setParameter(std::string("SecurityGroupName"), securityGroupName);
+}
+
+std::string CreateClusterRequest::getImageOwnerAlias() const {
+  return imageOwnerAlias_;
+}
+
+void CreateClusterRequest::setImageOwnerAlias(const std::string &imageOwnerAlias) {
+  imageOwnerAlias_ = imageOwnerAlias;
+  setParameter(std::string("ImageOwnerAlias"), imageOwnerAlias);
+}
+
+std::string CreateClusterRequest::getDeployMode() const {
+  return deployMode_;
+}
+
+void CreateClusterRequest::setDeployMode(const std::string &deployMode) {
+  deployMode_ = deployMode;
+  setParameter(std::string("DeployMode"), deployMode);
+}
+
+int CreateClusterRequest::getEcsOrderManagerCount() const {
+  return ecsOrderManagerCount_;
+}
+
+void CreateClusterRequest::setEcsOrderManagerCount(int ecsOrderManagerCount) {
+  ecsOrderManagerCount_ = ecsOrderManagerCount;
+  setParameter(std::string("EcsOrder.Manager.Count"), std::to_string(ecsOrderManagerCount));
+}
+
+std::string CreateClusterRequest::getResourceGroupId() const {
+  return resourceGroupId_;
+}
+
+void CreateClusterRequest::setResourceGroupId(const std::string &resourceGroupId) {
+  resourceGroupId_ = resourceGroupId;
+  setParameter(std::string("ResourceGroupId"), resourceGroupId);
+}
+
+std::string CreateClusterRequest::getPassword() const {
+  return password_;
+}
+
+void CreateClusterRequest::setPassword(const std::string &password) {
+  password_ = password;
+  setParameter(std::string("Password"), password);
+}
+
+int CreateClusterRequest::getEcsOrderLoginCount() const {
+  return ecsOrderLoginCount_;
+}
+
+void CreateClusterRequest::setEcsOrderLoginCount(int ecsOrderLoginCount) {
+  ecsOrderLoginCount_ = ecsOrderLoginCount;
+  setParameter(std::string("EcsOrder.Login.Count"), std::to_string(ecsOrderLoginCount));
+}
+
+bool CreateClusterRequest::getWithoutElasticIp() const {
+  return withoutElasticIp_;
+}
+
+void CreateClusterRequest::setWithoutElasticIp(bool withoutElasticIp) {
+  withoutElasticIp_ = withoutElasticIp;
+  setParameter(std::string("WithoutElasticIp"), withoutElasticIp ? "true" : "false");
+}
+
+std::string CreateClusterRequest::getRemoteVisEnable() const {
+  return remoteVisEnable_;
+}
+
+void CreateClusterRequest::setRemoteVisEnable(const std::string &remoteVisEnable) {
+  remoteVisEnable_ = remoteVisEnable;
+  setParameter(std::string("RemoteVisEnable"), remoteVisEnable);
+}
+
+int CreateClusterRequest::getSystemDiskSize() const {
+  return systemDiskSize_;
+}
+
+void CreateClusterRequest::setSystemDiskSize(int systemDiskSize) {
+  systemDiskSize_ = systemDiskSize;
+  setParameter(std::string("SystemDiskSize"), std::to_string(systemDiskSize));
+}
+
+std::vector<CreateClusterRequest::Tag> CreateClusterRequest::getTag() const {
+  return tag_;
+}
+
+void CreateClusterRequest::setTag(const std::vector<CreateClusterRequest::Tag> &tag) {
+  tag_ = tag;
+  for(int dep1 = 0; dep1 != tag.size(); dep1++) {
+  auto tagObj = tag.at(dep1);
+  std::string tagObjStr = std::string("Tag") + "." + std::to_string(dep1 + 1);
+    setParameter(tagObjStr + ".Value", tagObj.value);
+    setParameter(tagObjStr + ".Key", tagObj.key);
+  }
+}
+
+std::string CreateClusterRequest::getComputeSpotPriceLimit() const {
+  return computeSpotPriceLimit_;
+}
+
+void CreateClusterRequest::setComputeSpotPriceLimit(const std::string &computeSpotPriceLimit) {
+  computeSpotPriceLimit_ = computeSpotPriceLimit;
+  setParameter(std::string("ComputeSpotPriceLimit"), computeSpotPriceLimit);
+}
+
+int CreateClusterRequest::getAutoRenewPeriod() const {
+  return autoRenewPeriod_;
+}
+
+void CreateClusterRequest::setAutoRenewPeriod(int autoRenewPeriod) {
+  autoRenewPeriod_ = autoRenewPeriod;
+  setParameter(std::string("AutoRenewPeriod"), std::to_string(autoRenewPeriod));
+}
+
+int CreateClusterRequest::getPeriod() const {
+  return period_;
+}
+
+void CreateClusterRequest::setPeriod(int period) {
+  period_ = period;
+  setParameter(std::string("Period"), std::to_string(period));
+}
+
+std::string CreateClusterRequest::getRemoteDirectory() const {
+  return remoteDirectory_;
+}
+
+void CreateClusterRequest::setRemoteDirectory(const std::string &remoteDirectory) {
+  remoteDirectory_ = remoteDirectory;
+  setParameter(std::string("RemoteDirectory"), remoteDirectory);
+}
+
+int CreateClusterRequest::getEcsOrderComputeCount() const {
+  return ecsOrderComputeCount_;
+}
+
+void CreateClusterRequest::setEcsOrderComputeCount(int ecsOrderComputeCount) {
+  ecsOrderComputeCount_ = ecsOrderComputeCount;
+  setParameter(std::string("EcsOrder.Compute.Count"), std::to_string(ecsOrderComputeCount));
+}
+
+std::string CreateClusterRequest::getComputeSpotStrategy() const {
+  return computeSpotStrategy_;
+}
+
+void CreateClusterRequest::setComputeSpotStrategy(const std::string &computeSpotStrategy) {
+  computeSpotStrategy_ = computeSpotStrategy;
+  setParameter(std::string("ComputeSpotStrategy"), computeSpotStrategy);
+}
+
+std::vector<CreateClusterRequest::PostInstallScript> CreateClusterRequest::getPostInstallScript() const {
+  return postInstallScript_;
+}
+
+void CreateClusterRequest::setPostInstallScript(const std::vector<CreateClusterRequest::PostInstallScript> &postInstallScript) {
+  postInstallScript_ = postInstallScript;
+  for(int dep1 = 0; dep1 != postInstallScript.size(); dep1++) {
+  auto postInstallScriptObj = postInstallScript.at(dep1);
+  std::string postInstallScriptObjStr = std::string("PostInstallScript") + "." + std::to_string(dep1 + 1);
+    setParameter(postInstallScriptObjStr + ".Args", postInstallScriptObj.args);
+    setParameter(postInstallScriptObjStr + ".Url", postInstallScriptObj.url);
+  }
+}
+
+std::vector<std::string> CreateClusterRequest::getRamNodeTypes() const {
+  return ramNodeTypes_;
+}
+
+void CreateClusterRequest::setRamNodeTypes(const std::vector<std::string> &ramNodeTypes) {
+  ramNodeTypes_ = ramNodeTypes;
+}
+
+std::string CreateClusterRequest::getVSwitchId() const {
+  return vSwitchId_;
+}
+
+void CreateClusterRequest::setVSwitchId(const std::string &vSwitchId) {
+  vSwitchId_ = vSwitchId;
+  setParameter(std::string("VSwitchId"), vSwitchId);
+}
+
+std::string CreateClusterRequest::getPeriodUnit() const {
+  return periodUnit_;
+}
+
+void CreateClusterRequest::setPeriodUnit(const std::string &periodUnit) {
+  periodUnit_ = periodUnit;
+  setParameter(std::string("PeriodUnit"), periodUnit);
+}
+
+bool CreateClusterRequest::getComputeEnableHt() const {
+  return computeEnableHt_;
+}
+
+void CreateClusterRequest::setComputeEnableHt(bool computeEnableHt) {
+  computeEnableHt_ = computeEnableHt;
+  setParameter(std::string("ComputeEnableHt"), computeEnableHt ? "true" : "false");
+}
+
+std::string CreateClusterRequest::getAutoRenew() const {
+  return autoRenew_;
+}
+
+void CreateClusterRequest::setAutoRenew(const std::string &autoRenew) {
+  autoRenew_ = autoRenew;
+  setParameter(std::string("AutoRenew"), autoRenew);
+}
+
+std::string CreateClusterRequest::getDomain() const {
+  return domain_;
+}
+
+void CreateClusterRequest::setDomain(const std::string &domain) {
+  domain_ = domain;
+  setParameter(std::string("Domain"), domain);
+}
+
+std::string CreateClusterRequest::getName() const {
+  return name_;
+}
+
+void CreateClusterRequest::setName(const std::string &name) {
+  name_ = name;
+  setParameter(std::string("Name"), name);
+}
+
+std::string CreateClusterRequest::getVolumeId() const {
+  return volumeId_;
+}
+
+void CreateClusterRequest::setVolumeId(const std::string &volumeId) {
+  volumeId_ = volumeId;
+  setParameter(std::string("VolumeId"), volumeId);
+}
+
+std::string CreateClusterRequest::getZoneId() const {
+  return zoneId_;
+}
+
+void CreateClusterRequest::setZoneId(const std::string &zoneId) {
+  zoneId_ = zoneId;
+  setParameter(std::string("ZoneId"), zoneId);
+}
+
 std::string CreateClusterRequest::getSccClusterId() const {
   return sccClusterId_;
 }
@@ -34,6 +330,15 @@ void CreateClusterRequest::setSccClusterId(const std::string &sccClusterId) {
   setParameter(std::string("SccClusterId"), sccClusterId);
 }
 
+std::string CreateClusterRequest::getVolumeMountOption() const {
+  return volumeMountOption_;
+}
+
+void CreateClusterRequest::setVolumeMountOption(const std::string &volumeMountOption) {
+  volumeMountOption_ = volumeMountOption;
+  setParameter(std::string("VolumeMountOption"), volumeMountOption);
+}
+
 std::string CreateClusterRequest::getImageId() const {
   return imageId_;
 }
@@ -43,13 +348,22 @@ void CreateClusterRequest::setImageId(const std::string &imageId) {
   setParameter(std::string("ImageId"), imageId);
 }
 
-std::string CreateClusterRequest::getEcsOrderManagerInstanceType() const {
-  return ecsOrderManagerInstanceType_;
+std::string CreateClusterRequest::getSystemDiskLevel() const {
+  return systemDiskLevel_;
 }
 
-void CreateClusterRequest::setEcsOrderManagerInstanceType(const std::string &ecsOrderManagerInstanceType) {
-  ecsOrderManagerInstanceType_ = ecsOrderManagerInstanceType;
-  setParameter(std::string("EcsOrder.Manager.InstanceType"), ecsOrderManagerInstanceType);
+void CreateClusterRequest::setSystemDiskLevel(const std::string &systemDiskLevel) {
+  systemDiskLevel_ = systemDiskLevel;
+  setParameter(std::string("SystemDiskLevel"), systemDiskLevel);
+}
+
+std::string CreateClusterRequest::getClientToken() const {
+  return clientToken_;
+}
+
+void CreateClusterRequest::setClientToken(const std::string &clientToken) {
+  clientToken_ = clientToken;
+  setParameter(std::string("ClientToken"), clientToken);
 }
 
 std::string CreateClusterRequest::getEhpcVersion() const {
@@ -88,24 +402,6 @@ void CreateClusterRequest::setDescription(const std::string &description) {
   setParameter(std::string("Description"), description);
 }
 
-std::string CreateClusterRequest::getKeyPairName() const {
-  return keyPairName_;
-}
-
-void CreateClusterRequest::setKeyPairName(const std::string &keyPairName) {
-  keyPairName_ = keyPairName;
-  setParameter(std::string("KeyPairName"), keyPairName);
-}
-
-std::string CreateClusterRequest::getSecurityGroupName() const {
-  return securityGroupName_;
-}
-
-void CreateClusterRequest::setSecurityGroupName(const std::string &securityGroupName) {
-  securityGroupName_ = securityGroupName;
-  setParameter(std::string("SecurityGroupName"), securityGroupName);
-}
-
 std::string CreateClusterRequest::getEcsOrderComputeInstanceType() const {
   return ecsOrderComputeInstanceType_;
 }
@@ -115,6 +411,15 @@ void CreateClusterRequest::setEcsOrderComputeInstanceType(const std::string &ecs
   setParameter(std::string("EcsOrder.Compute.InstanceType"), ecsOrderComputeInstanceType);
 }
 
+std::string CreateClusterRequest::getJobQueue() const {
+  return jobQueue_;
+}
+
+void CreateClusterRequest::setJobQueue(const std::string &jobQueue) {
+  jobQueue_ = jobQueue;
+  setParameter(std::string("JobQueue"), jobQueue);
+}
+
 std::string CreateClusterRequest::getAccessKeyId() const {
   return accessKeyId_;
 }
@@ -124,15 +429,6 @@ void CreateClusterRequest::setAccessKeyId(const std::string &accessKeyId) {
   setParameter(std::string("AccessKeyId"), accessKeyId);
 }
 
-std::string CreateClusterRequest::getImageOwnerAlias() const {
-  return imageOwnerAlias_;
-}
-
-void CreateClusterRequest::setImageOwnerAlias(const std::string &imageOwnerAlias) {
-  imageOwnerAlias_ = imageOwnerAlias;
-  setParameter(std::string("ImageOwnerAlias"), imageOwnerAlias);
-}
-
 std::string CreateClusterRequest::getVolumeType() const {
   return volumeType_;
 }
@@ -142,40 +438,13 @@ void CreateClusterRequest::setVolumeType(const std::string &volumeType) {
   setParameter(std::string("VolumeType"), volumeType);
 }
 
-int CreateClusterRequest::getEcsOrderManagerCount() const {
-  return ecsOrderManagerCount_;
+std::string CreateClusterRequest::getSystemDiskType() const {
+  return systemDiskType_;
 }
 
-void CreateClusterRequest::setEcsOrderManagerCount(int ecsOrderManagerCount) {
-  ecsOrderManagerCount_ = ecsOrderManagerCount;
-  setParameter(std::string("EcsOrder.Manager.Count"), std::to_string(ecsOrderManagerCount));
-}
-
-std::string CreateClusterRequest::getPassword() const {
-  return password_;
-}
-
-void CreateClusterRequest::setPassword(const std::string &password) {
-  password_ = password;
-  setParameter(std::string("Password"), password);
-}
-
-int CreateClusterRequest::getEcsOrderLoginCount() const {
-  return ecsOrderLoginCount_;
-}
-
-void CreateClusterRequest::setEcsOrderLoginCount(int ecsOrderLoginCount) {
-  ecsOrderLoginCount_ = ecsOrderLoginCount;
-  setParameter(std::string("EcsOrder.Login.Count"), std::to_string(ecsOrderLoginCount));
-}
-
-std::string CreateClusterRequest::getComputeSpotPriceLimit() const {
-  return computeSpotPriceLimit_;
-}
-
-void CreateClusterRequest::setComputeSpotPriceLimit(const std::string &computeSpotPriceLimit) {
-  computeSpotPriceLimit_ = computeSpotPriceLimit;
-  setParameter(std::string("ComputeSpotPriceLimit"), computeSpotPriceLimit);
+void CreateClusterRequest::setSystemDiskType(const std::string &systemDiskType) {
+  systemDiskType_ = systemDiskType;
+  setParameter(std::string("SystemDiskType"), systemDiskType);
 }
 
 std::string CreateClusterRequest::getVolumeProtocol() const {
@@ -187,6 +456,15 @@ void CreateClusterRequest::setVolumeProtocol(const std::string &volumeProtocol)
   setParameter(std::string("VolumeProtocol"), volumeProtocol);
 }
 
+std::string CreateClusterRequest::getClientVersion() const {
+  return clientVersion_;
+}
+
+void CreateClusterRequest::setClientVersion(const std::string &clientVersion) {
+  clientVersion_ = clientVersion;
+  setParameter(std::string("ClientVersion"), clientVersion);
+}
+
 std::string CreateClusterRequest::getOsTag() const {
   return osTag_;
 }
@@ -196,40 +474,40 @@ void CreateClusterRequest::setOsTag(const std::string &osTag) {
   setParameter(std::string("OsTag"), osTag);
 }
 
-std::string CreateClusterRequest::getRemoteDirectory() const {
-  return remoteDirectory_;
+std::string CreateClusterRequest::getClusterVersion() const {
+  return clusterVersion_;
 }
 
-void CreateClusterRequest::setRemoteDirectory(const std::string &remoteDirectory) {
-  remoteDirectory_ = remoteDirectory;
-  setParameter(std::string("RemoteDirectory"), remoteDirectory);
+void CreateClusterRequest::setClusterVersion(const std::string &clusterVersion) {
+  clusterVersion_ = clusterVersion;
+  setParameter(std::string("ClusterVersion"), clusterVersion);
 }
 
-int CreateClusterRequest::getEcsOrderComputeCount() const {
-  return ecsOrderComputeCount_;
+bool CreateClusterRequest::getIsComputeEss() const {
+  return isComputeEss_;
 }
 
-void CreateClusterRequest::setEcsOrderComputeCount(int ecsOrderComputeCount) {
-  ecsOrderComputeCount_ = ecsOrderComputeCount;
-  setParameter(std::string("EcsOrder.Compute.Count"), std::to_string(ecsOrderComputeCount));
+void CreateClusterRequest::setIsComputeEss(bool isComputeEss) {
+  isComputeEss_ = isComputeEss;
+  setParameter(std::string("IsComputeEss"), isComputeEss ? "true" : "false");
 }
 
-std::string CreateClusterRequest::getComputeSpotStrategy() const {
-  return computeSpotStrategy_;
+std::string CreateClusterRequest::getRamRoleName() const {
+  return ramRoleName_;
 }
 
-void CreateClusterRequest::setComputeSpotStrategy(const std::string &computeSpotStrategy) {
-  computeSpotStrategy_ = computeSpotStrategy;
-  setParameter(std::string("ComputeSpotStrategy"), computeSpotStrategy);
+void CreateClusterRequest::setRamRoleName(const std::string &ramRoleName) {
+  ramRoleName_ = ramRoleName;
+  setParameter(std::string("RamRoleName"), ramRoleName);
 }
 
-std::string CreateClusterRequest::getVSwitchId() const {
-  return vSwitchId_;
+std::string CreateClusterRequest::getPlugin() const {
+  return plugin_;
 }
 
-void CreateClusterRequest::setVSwitchId(const std::string &vSwitchId) {
-  vSwitchId_ = vSwitchId;
-  setParameter(std::string("VSwitchId"), vSwitchId);
+void CreateClusterRequest::setPlugin(const std::string &plugin) {
+  plugin_ = plugin;
+  setParameter(std::string("Plugin"), plugin);
 }
 
 std::vector<CreateClusterRequest::Application> CreateClusterRequest::getApplication() const {
@@ -254,6 +532,15 @@ void CreateClusterRequest::setEcsChargeType(const std::string &ecsChargeType) {
   setParameter(std::string("EcsChargeType"), ecsChargeType);
 }
 
+std::string CreateClusterRequest::getInputFileUrl() const {
+  return inputFileUrl_;
+}
+
+void CreateClusterRequest::setInputFileUrl(const std::string &inputFileUrl) {
+  inputFileUrl_ = inputFileUrl;
+  setParameter(std::string("InputFileUrl"), inputFileUrl);
+}
+
 std::string CreateClusterRequest::getVpcId() const {
   return vpcId_;
 }
@@ -272,13 +559,13 @@ void CreateClusterRequest::setHaEnable(bool haEnable) {
   setParameter(std::string("HaEnable"), haEnable ? "true" : "false");
 }
 
-std::string CreateClusterRequest::getName() const {
-  return name_;
+bool CreateClusterRequest::getWithoutAgent() const {
+  return withoutAgent_;
 }
 
-void CreateClusterRequest::setName(const std::string &name) {
-  name_ = name;
-  setParameter(std::string("Name"), name);
+void CreateClusterRequest::setWithoutAgent(bool withoutAgent) {
+  withoutAgent_ = withoutAgent;
+  setParameter(std::string("WithoutAgent"), withoutAgent ? "true" : "false");
 }
 
 std::string CreateClusterRequest::getSchedulerType() const {
@@ -290,15 +577,6 @@ void CreateClusterRequest::setSchedulerType(const std::string &schedulerType) {
   setParameter(std::string("SchedulerType"), schedulerType);
 }
 
-std::string CreateClusterRequest::getVolumeId() const {
-  return volumeId_;
-}
-
-void CreateClusterRequest::setVolumeId(const std::string &volumeId) {
-  volumeId_ = volumeId;
-  setParameter(std::string("VolumeId"), volumeId);
-}
-
 std::string CreateClusterRequest::getVolumeMountpoint() const {
   return volumeMountpoint_;
 }
@@ -317,12 +595,3 @@ void CreateClusterRequest::setEcsOrderLoginInstanceType(const std::string &ecsOr
   setParameter(std::string("EcsOrder.Login.InstanceType"), ecsOrderLoginInstanceType);
 }
 
-std::string CreateClusterRequest::getZoneId() const {
-  return zoneId_;
-}
-
-void CreateClusterRequest::setZoneId(const std::string &zoneId) {
-  zoneId_ = zoneId;
-  setParameter(std::string("ZoneId"), zoneId);
-}
-

ehpc/src/model/CreateClusterResult.cc

@@ -39,11 +39,18 @@ void CreateClusterResult::parse(const std::string &payload)
 	Json::Value value;
 	reader.parse(payload, value);
 	setRequestId(value["RequestId"].asString());
+	if(!value["TaskId"].isNull())
+		taskId_ = value["TaskId"].asString();
 	if(!value["ClusterId"].isNull())
 		clusterId_ = value["ClusterId"].asString();
 
 }
 
+std::string CreateClusterResult::getTaskId()const
+{
+	return taskId_;
+}
+
 std::string CreateClusterResult::getClusterId()const
 {
 	return clusterId_;

ehpc/src/model/CreateGWSClusterRequest.cc

@@ -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.
+ */
+
+#include <alibabacloud/ehpc/model/CreateGWSClusterRequest.h>
+
+using AlibabaCloud::EHPC::Model::CreateGWSClusterRequest;
+
+CreateGWSClusterRequest::CreateGWSClusterRequest()
+    : RpcServiceRequest("ehpc", "2018-04-12", "CreateGWSCluster") {
+  setMethod(HttpRequest::Method::Get);
+}
+
+CreateGWSClusterRequest::~CreateGWSClusterRequest() {}
+
+std::string CreateGWSClusterRequest::getAccessKeyId() const {
+  return accessKeyId_;
+}
+
+void CreateGWSClusterRequest::setAccessKeyId(const std::string &accessKeyId) {
+  accessKeyId_ = accessKeyId;
+  setParameter(std::string("AccessKeyId"), accessKeyId);
+}
+
+std::string CreateGWSClusterRequest::getClusterType() const {
+  return clusterType_;
+}
+
+void CreateGWSClusterRequest::setClusterType(const std::string &clusterType) {
+  clusterType_ = clusterType;
+  setParameter(std::string("ClusterType"), clusterType);
+}
+
+std::string CreateGWSClusterRequest::getVSwitchId() const {
+  return vSwitchId_;
+}
+
+void CreateGWSClusterRequest::setVSwitchId(const std::string &vSwitchId) {
+  vSwitchId_ = vSwitchId;
+  setParameter(std::string("VSwitchId"), vSwitchId);
+}
+
+std::string CreateGWSClusterRequest::getVpcId() const {
+  return vpcId_;
+}
+
+void CreateGWSClusterRequest::setVpcId(const std::string &vpcId) {
+  vpcId_ = vpcId;
+  setParameter(std::string("VpcId"), vpcId);
+}
+
+std::string CreateGWSClusterRequest::getName() const {
+  return name_;
+}
+
+void CreateGWSClusterRequest::setName(const std::string &name) {
+  name_ = name;
+  setParameter(std::string("Name"), name);
+}
+

ehpc/src/model/CreateGWSClusterResult.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/ehpc/model/CreateGWSClusterResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::EHPC;
+using namespace AlibabaCloud::EHPC::Model;
+
+CreateGWSClusterResult::CreateGWSClusterResult() :
+	ServiceResult()
+{}
+
+CreateGWSClusterResult::CreateGWSClusterResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+CreateGWSClusterResult::~CreateGWSClusterResult()
+{}
+
+void CreateGWSClusterResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	if(!value["ClusterId"].isNull())
+		clusterId_ = value["ClusterId"].asString();
+
+}
+
+std::string CreateGWSClusterResult::getClusterId()const
+{
+	return clusterId_;
+}
+

ehpc/src/model/CreateGWSImageRequest.cc

@@ -0,0 +1,54 @@
+/*
+ * 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/ehpc/model/CreateGWSImageRequest.h>
+
+using AlibabaCloud::EHPC::Model::CreateGWSImageRequest;
+
+CreateGWSImageRequest::CreateGWSImageRequest()
+    : RpcServiceRequest("ehpc", "2018-04-12", "CreateGWSImage") {
+  setMethod(HttpRequest::Method::Get);
+}
+
+CreateGWSImageRequest::~CreateGWSImageRequest() {}
+
+std::string CreateGWSImageRequest::getAccessKeyId() const {
+  return accessKeyId_;
+}
+
+void CreateGWSImageRequest::setAccessKeyId(const std::string &accessKeyId) {
+  accessKeyId_ = accessKeyId;
+  setParameter(std::string("AccessKeyId"), accessKeyId);
+}
+
+std::string CreateGWSImageRequest::getInstanceId() const {
+  return instanceId_;
+}
+
+void CreateGWSImageRequest::setInstanceId(const std::string &instanceId) {
+  instanceId_ = instanceId;
+  setParameter(std::string("InstanceId"), instanceId);
+}
+
+std::string CreateGWSImageRequest::getName() const {
+  return name_;
+}
+
+void CreateGWSImageRequest::setName(const std::string &name) {
+  name_ = name;
+  setParameter(std::string("Name"), name);
+}
+

ehpc/src/model/CreateGWSImageResult.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/ehpc/model/CreateGWSImageResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::EHPC;
+using namespace AlibabaCloud::EHPC::Model;
+
+CreateGWSImageResult::CreateGWSImageResult() :
+	ServiceResult()
+{}
+
+CreateGWSImageResult::CreateGWSImageResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+CreateGWSImageResult::~CreateGWSImageResult()
+{}
+
+void CreateGWSImageResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	if(!value["ImageId"].isNull())
+		imageId_ = value["ImageId"].asString();
+
+}
+
+std::string CreateGWSImageResult::getImageId()const
+{
+	return imageId_;
+}
+

ehpc/src/model/CreateGWSInstanceRequest.cc

@@ -0,0 +1,189 @@
+/*
+ * 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/ehpc/model/CreateGWSInstanceRequest.h>
+
+using AlibabaCloud::EHPC::Model::CreateGWSInstanceRequest;
+
+CreateGWSInstanceRequest::CreateGWSInstanceRequest()
+    : RpcServiceRequest("ehpc", "2018-04-12", "CreateGWSInstance") {
+  setMethod(HttpRequest::Method::Get);
+}
+
+CreateGWSInstanceRequest::~CreateGWSInstanceRequest() {}
+
+std::string CreateGWSInstanceRequest::getImageId() const {
+  return imageId_;
+}
+
+void CreateGWSInstanceRequest::setImageId(const std::string &imageId) {
+  imageId_ = imageId;
+  setParameter(std::string("ImageId"), imageId);
+}
+
+bool CreateGWSInstanceRequest::getAllocatePublicAddress() const {
+  return allocatePublicAddress_;
+}
+
+void CreateGWSInstanceRequest::setAllocatePublicAddress(bool allocatePublicAddress) {
+  allocatePublicAddress_ = allocatePublicAddress;
+  setParameter(std::string("AllocatePublicAddress"), allocatePublicAddress ? "true" : "false");
+}
+
+std::string CreateGWSInstanceRequest::getAppList() const {
+  return appList_;
+}
+
+void CreateGWSInstanceRequest::setAppList(const std::string &appList) {
+  appList_ = appList;
+  setParameter(std::string("AppList"), appList);
+}
+
+int CreateGWSInstanceRequest::getInternetMaxBandwidthOut() const {
+  return internetMaxBandwidthOut_;
+}
+
+void CreateGWSInstanceRequest::setInternetMaxBandwidthOut(int internetMaxBandwidthOut) {
+  internetMaxBandwidthOut_ = internetMaxBandwidthOut;
+  setParameter(std::string("InternetMaxBandwidthOut"), std::to_string(internetMaxBandwidthOut));
+}
+
+std::string CreateGWSInstanceRequest::getAccessKeyId() const {
+  return accessKeyId_;
+}
+
+void CreateGWSInstanceRequest::setAccessKeyId(const std::string &accessKeyId) {
+  accessKeyId_ = accessKeyId;
+  setParameter(std::string("AccessKeyId"), accessKeyId);
+}
+
+std::string CreateGWSInstanceRequest::getSystemDiskCategory() const {
+  return systemDiskCategory_;
+}
+
+void CreateGWSInstanceRequest::setSystemDiskCategory(const std::string &systemDiskCategory) {
+  systemDiskCategory_ = systemDiskCategory;
+  setParameter(std::string("SystemDiskCategory"), systemDiskCategory);
+}
+
+int CreateGWSInstanceRequest::getSystemDiskSize() const {
+  return systemDiskSize_;
+}
+
+void CreateGWSInstanceRequest::setSystemDiskSize(int systemDiskSize) {
+  systemDiskSize_ = systemDiskSize;
+  setParameter(std::string("SystemDiskSize"), std::to_string(systemDiskSize));
+}
+
+std::string CreateGWSInstanceRequest::getInstanceType() const {
+  return instanceType_;
+}
+
+void CreateGWSInstanceRequest::setInstanceType(const std::string &instanceType) {
+  instanceType_ = instanceType;
+  setParameter(std::string("InstanceType"), instanceType);
+}
+
+std::string CreateGWSInstanceRequest::getInstanceChargeType() const {
+  return instanceChargeType_;
+}
+
+void CreateGWSInstanceRequest::setInstanceChargeType(const std::string &instanceChargeType) {
+  instanceChargeType_ = instanceChargeType;
+  setParameter(std::string("InstanceChargeType"), instanceChargeType);
+}
+
+std::string CreateGWSInstanceRequest::getPeriod() const {
+  return period_;
+}
+
+void CreateGWSInstanceRequest::setPeriod(const std::string &period) {
+  period_ = period;
+  setParameter(std::string("Period"), period);
+}
+
+std::string CreateGWSInstanceRequest::getClusterId() const {
+  return clusterId_;
+}
+
+void CreateGWSInstanceRequest::setClusterId(const std::string &clusterId) {
+  clusterId_ = clusterId;
+  setParameter(std::string("ClusterId"), clusterId);
+}
+
+std::string CreateGWSInstanceRequest::getWorkMode() const {
+  return workMode_;
+}
+
+void CreateGWSInstanceRequest::setWorkMode(const std::string &workMode) {
+  workMode_ = workMode;
+  setParameter(std::string("WorkMode"), workMode);
+}
+
+std::string CreateGWSInstanceRequest::getVSwitchId() const {
+  return vSwitchId_;
+}
+
+void CreateGWSInstanceRequest::setVSwitchId(const std::string &vSwitchId) {
+  vSwitchId_ = vSwitchId;
+  setParameter(std::string("VSwitchId"), vSwitchId);
+}
+
+std::string CreateGWSInstanceRequest::getPeriodUnit() const {
+  return periodUnit_;
+}
+
+void CreateGWSInstanceRequest::setPeriodUnit(const std::string &periodUnit) {
+  periodUnit_ = periodUnit;
+  setParameter(std::string("PeriodUnit"), periodUnit);
+}
+
+bool CreateGWSInstanceRequest::getAutoRenew() const {
+  return autoRenew_;
+}
+
+void CreateGWSInstanceRequest::setAutoRenew(bool autoRenew) {
+  autoRenew_ = autoRenew;
+  setParameter(std::string("AutoRenew"), autoRenew ? "true" : "false");
+}
+
+std::string CreateGWSInstanceRequest::getInternetChargeType() const {
+  return internetChargeType_;
+}
+
+void CreateGWSInstanceRequest::setInternetChargeType(const std::string &internetChargeType) {
+  internetChargeType_ = internetChargeType;
+  setParameter(std::string("InternetChargeType"), internetChargeType);
+}
+
+std::string CreateGWSInstanceRequest::getName() const {
+  return name_;
+}
+
+void CreateGWSInstanceRequest::setName(const std::string &name) {
+  name_ = name;
+  setParameter(std::string("Name"), name);
+}
+
+int CreateGWSInstanceRequest::getInternetMaxBandwidthIn() const {
+  return internetMaxBandwidthIn_;
+}
+
+void CreateGWSInstanceRequest::setInternetMaxBandwidthIn(int internetMaxBandwidthIn) {
+  internetMaxBandwidthIn_ = internetMaxBandwidthIn;
+  setParameter(std::string("InternetMaxBandwidthIn"), std::to_string(internetMaxBandwidthIn));
+}
+

ehpc/src/model/CreateGWSInstanceResult.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/ehpc/model/CreateGWSInstanceResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::EHPC;
+using namespace AlibabaCloud::EHPC::Model;
+
+CreateGWSInstanceResult::CreateGWSInstanceResult() :
+	ServiceResult()
+{}
+
+CreateGWSInstanceResult::CreateGWSInstanceResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+CreateGWSInstanceResult::~CreateGWSInstanceResult()
+{}
+
+void CreateGWSInstanceResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	if(!value["InstanceId"].isNull())
+		instanceId_ = value["InstanceId"].asString();
+
+}
+
+std::string CreateGWSInstanceResult::getInstanceId()const
+{
+	return instanceId_;
+}
+

ehpc/src/model/CreateHybridClusterRequest.cc

@@ -0,0 +1,387 @@
+/*
+ * 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/ehpc/model/CreateHybridClusterRequest.h>
+
+using AlibabaCloud::EHPC::Model::CreateHybridClusterRequest;
+
+CreateHybridClusterRequest::CreateHybridClusterRequest()
+    : RpcServiceRequest("ehpc", "2018-04-12", "CreateHybridCluster") {
+  setMethod(HttpRequest::Method::Get);
+}
+
+CreateHybridClusterRequest::~CreateHybridClusterRequest() {}
+
+std::string CreateHybridClusterRequest::getEcsOrderManagerInstanceType() const {
+  return ecsOrderManagerInstanceType_;
+}
+
+void CreateHybridClusterRequest::setEcsOrderManagerInstanceType(const std::string &ecsOrderManagerInstanceType) {
+  ecsOrderManagerInstanceType_ = ecsOrderManagerInstanceType;
+  setParameter(std::string("EcsOrder.Manager.InstanceType"), ecsOrderManagerInstanceType);
+}
+
+std::string CreateHybridClusterRequest::getKeyPairName() const {
+  return keyPairName_;
+}
+
+void CreateHybridClusterRequest::setKeyPairName(const std::string &keyPairName) {
+  keyPairName_ = keyPairName;
+  setParameter(std::string("KeyPairName"), keyPairName);
+}
+
+bool CreateHybridClusterRequest::getMultiOs() const {
+  return multiOs_;
+}
+
+void CreateHybridClusterRequest::setMultiOs(bool multiOs) {
+  multiOs_ = multiOs;
+  setParameter(std::string("MultiOs"), multiOs ? "true" : "false");
+}
+
+std::string CreateHybridClusterRequest::getSecurityGroupName() const {
+  return securityGroupName_;
+}
+
+void CreateHybridClusterRequest::setSecurityGroupName(const std::string &securityGroupName) {
+  securityGroupName_ = securityGroupName;
+  setParameter(std::string("SecurityGroupName"), securityGroupName);
+}
+
+std::string CreateHybridClusterRequest::getOnPremiseVolumeRemotePath() const {
+  return onPremiseVolumeRemotePath_;
+}
+
+void CreateHybridClusterRequest::setOnPremiseVolumeRemotePath(const std::string &onPremiseVolumeRemotePath) {
+  onPremiseVolumeRemotePath_ = onPremiseVolumeRemotePath;
+  setParameter(std::string("OnPremiseVolumeRemotePath"), onPremiseVolumeRemotePath);
+}
+
+std::string CreateHybridClusterRequest::getImageOwnerAlias() const {
+  return imageOwnerAlias_;
+}
+
+void CreateHybridClusterRequest::setImageOwnerAlias(const std::string &imageOwnerAlias) {
+  imageOwnerAlias_ = imageOwnerAlias;
+  setParameter(std::string("ImageOwnerAlias"), imageOwnerAlias);
+}
+
+std::string CreateHybridClusterRequest::getResourceGroupId() const {
+  return resourceGroupId_;
+}
+
+void CreateHybridClusterRequest::setResourceGroupId(const std::string &resourceGroupId) {
+  resourceGroupId_ = resourceGroupId;
+  setParameter(std::string("ResourceGroupId"), resourceGroupId);
+}
+
+std::string CreateHybridClusterRequest::getPassword() const {
+  return password_;
+}
+
+void CreateHybridClusterRequest::setPassword(const std::string &password) {
+  password_ = password;
+  setParameter(std::string("Password"), password);
+}
+
+float CreateHybridClusterRequest::getComputeSpotPriceLimit() const {
+  return computeSpotPriceLimit_;
+}
+
+void CreateHybridClusterRequest::setComputeSpotPriceLimit(float computeSpotPriceLimit) {
+  computeSpotPriceLimit_ = computeSpotPriceLimit;
+  setParameter(std::string("ComputeSpotPriceLimit"), std::to_string(computeSpotPriceLimit));
+}
+
+std::string CreateHybridClusterRequest::getOnPremiseVolumeLocalPath() const {
+  return onPremiseVolumeLocalPath_;
+}
+
+void CreateHybridClusterRequest::setOnPremiseVolumeLocalPath(const std::string &onPremiseVolumeLocalPath) {
+  onPremiseVolumeLocalPath_ = onPremiseVolumeLocalPath;
+  setParameter(std::string("OnPremiseVolumeLocalPath"), onPremiseVolumeLocalPath);
+}
+
+std::string CreateHybridClusterRequest::getRemoteDirectory() const {
+  return remoteDirectory_;
+}
+
+void CreateHybridClusterRequest::setRemoteDirectory(const std::string &remoteDirectory) {
+  remoteDirectory_ = remoteDirectory;
+  setParameter(std::string("RemoteDirectory"), remoteDirectory);
+}
+
+std::string CreateHybridClusterRequest::getComputeSpotStrategy() const {
+  return computeSpotStrategy_;
+}
+
+void CreateHybridClusterRequest::setComputeSpotStrategy(const std::string &computeSpotStrategy) {
+  computeSpotStrategy_ = computeSpotStrategy;
+  setParameter(std::string("ComputeSpotStrategy"), computeSpotStrategy);
+}
+
+std::vector<CreateHybridClusterRequest::PostInstallScript> CreateHybridClusterRequest::getPostInstallScript() const {
+  return postInstallScript_;
+}
+
+void CreateHybridClusterRequest::setPostInstallScript(const std::vector<CreateHybridClusterRequest::PostInstallScript> &postInstallScript) {
+  postInstallScript_ = postInstallScript;
+  for(int dep1 = 0; dep1 != postInstallScript.size(); dep1++) {
+  auto postInstallScriptObj = postInstallScript.at(dep1);
+  std::string postInstallScriptObjStr = std::string("PostInstallScript") + "." + std::to_string(dep1 + 1);
+    setParameter(postInstallScriptObjStr + ".Args", postInstallScriptObj.args);
+    setParameter(postInstallScriptObjStr + ".Url", postInstallScriptObj.url);
+  }
+}
+
+std::string CreateHybridClusterRequest::getVSwitchId() const {
+  return vSwitchId_;
+}
+
+void CreateHybridClusterRequest::setVSwitchId(const std::string &vSwitchId) {
+  vSwitchId_ = vSwitchId;
+  setParameter(std::string("VSwitchId"), vSwitchId);
+}
+
+std::string CreateHybridClusterRequest::getDomain() const {
+  return domain_;
+}
+
+void CreateHybridClusterRequest::setDomain(const std::string &domain) {
+  domain_ = domain;
+  setParameter(std::string("Domain"), domain);
+}
+
+std::string CreateHybridClusterRequest::getName() const {
+  return name_;
+}
+
+void CreateHybridClusterRequest::setName(const std::string &name) {
+  name_ = name;
+  setParameter(std::string("Name"), name);
+}
+
+std::string CreateHybridClusterRequest::getVolumeId() const {
+  return volumeId_;
+}
+
+void CreateHybridClusterRequest::setVolumeId(const std::string &volumeId) {
+  volumeId_ = volumeId;
+  setParameter(std::string("VolumeId"), volumeId);
+}
+
+std::string CreateHybridClusterRequest::getZoneId() const {
+  return zoneId_;
+}
+
+void CreateHybridClusterRequest::setZoneId(const std::string &zoneId) {
+  zoneId_ = zoneId;
+  setParameter(std::string("ZoneId"), zoneId);
+}
+
+std::string CreateHybridClusterRequest::getImageId() const {
+  return imageId_;
+}
+
+void CreateHybridClusterRequest::setImageId(const std::string &imageId) {
+  imageId_ = imageId;
+  setParameter(std::string("ImageId"), imageId);
+}
+
+std::string CreateHybridClusterRequest::getClientToken() const {
+  return clientToken_;
+}
+
+void CreateHybridClusterRequest::setClientToken(const std::string &clientToken) {
+  clientToken_ = clientToken;
+  setParameter(std::string("ClientToken"), clientToken);
+}
+
+std::string CreateHybridClusterRequest::getEhpcVersion() const {
+  return ehpcVersion_;
+}
+
+void CreateHybridClusterRequest::setEhpcVersion(const std::string &ehpcVersion) {
+  ehpcVersion_ = ehpcVersion;
+  setParameter(std::string("EhpcVersion"), ehpcVersion);
+}
+
+std::string CreateHybridClusterRequest::getSecurityGroupId() const {
+  return securityGroupId_;
+}
+
+void CreateHybridClusterRequest::setSecurityGroupId(const std::string &securityGroupId) {
+  securityGroupId_ = securityGroupId;
+  setParameter(std::string("SecurityGroupId"), securityGroupId);
+}
+
+std::string CreateHybridClusterRequest::getDescription() const {
+  return description_;
+}
+
+void CreateHybridClusterRequest::setDescription(const std::string &description) {
+  description_ = description;
+  setParameter(std::string("Description"), description);
+}
+
+std::string CreateHybridClusterRequest::getEcsOrderComputeInstanceType() const {
+  return ecsOrderComputeInstanceType_;
+}
+
+void CreateHybridClusterRequest::setEcsOrderComputeInstanceType(const std::string &ecsOrderComputeInstanceType) {
+  ecsOrderComputeInstanceType_ = ecsOrderComputeInstanceType;
+  setParameter(std::string("EcsOrder.Compute.InstanceType"), ecsOrderComputeInstanceType);
+}
+
+std::string CreateHybridClusterRequest::getJobQueue() const {
+  return jobQueue_;
+}
+
+void CreateHybridClusterRequest::setJobQueue(const std::string &jobQueue) {
+  jobQueue_ = jobQueue;
+  setParameter(std::string("JobQueue"), jobQueue);
+}
+
+std::string CreateHybridClusterRequest::getAccessKeyId() const {
+  return accessKeyId_;
+}
+
+void CreateHybridClusterRequest::setAccessKeyId(const std::string &accessKeyId) {
+  accessKeyId_ = accessKeyId;
+  setParameter(std::string("AccessKeyId"), accessKeyId);
+}
+
+std::string CreateHybridClusterRequest::getVolumeType() const {
+  return volumeType_;
+}
+
+void CreateHybridClusterRequest::setVolumeType(const std::string &volumeType) {
+  volumeType_ = volumeType;
+  setParameter(std::string("VolumeType"), volumeType);
+}
+
+std::string CreateHybridClusterRequest::getOnPremiseVolumeMountPoint() const {
+  return onPremiseVolumeMountPoint_;
+}
+
+void CreateHybridClusterRequest::setOnPremiseVolumeMountPoint(const std::string &onPremiseVolumeMountPoint) {
+  onPremiseVolumeMountPoint_ = onPremiseVolumeMountPoint;
+  setParameter(std::string("OnPremiseVolumeMountPoint"), onPremiseVolumeMountPoint);
+}
+
+std::string CreateHybridClusterRequest::getOnPremiseVolumeProtocol() const {
+  return onPremiseVolumeProtocol_;
+}
+
+void CreateHybridClusterRequest::setOnPremiseVolumeProtocol(const std::string &onPremiseVolumeProtocol) {
+  onPremiseVolumeProtocol_ = onPremiseVolumeProtocol;
+  setParameter(std::string("OnPremiseVolumeProtocol"), onPremiseVolumeProtocol);
+}
+
+std::string CreateHybridClusterRequest::getVolumeProtocol() const {
+  return volumeProtocol_;
+}
+
+void CreateHybridClusterRequest::setVolumeProtocol(const std::string &volumeProtocol) {
+  volumeProtocol_ = volumeProtocol;
+  setParameter(std::string("VolumeProtocol"), volumeProtocol);
+}
+
+std::string CreateHybridClusterRequest::getClientVersion() const {
+  return clientVersion_;
+}
+
+void CreateHybridClusterRequest::setClientVersion(const std::string &clientVersion) {
+  clientVersion_ = clientVersion;
+  setParameter(std::string("ClientVersion"), clientVersion);
+}
+
+std::string CreateHybridClusterRequest::getOsTag() const {
+  return osTag_;
+}
+
+void CreateHybridClusterRequest::setOsTag(const std::string &osTag) {
+  osTag_ = osTag;
+  setParameter(std::string("OsTag"), osTag);
+}
+
+std::vector<CreateHybridClusterRequest::Nodes> CreateHybridClusterRequest::getNodes() const {
+  return nodes_;
+}
+
+void CreateHybridClusterRequest::setNodes(const std::vector<CreateHybridClusterRequest::Nodes> &nodes) {
+  nodes_ = nodes;
+  for(int dep1 = 0; dep1 != nodes.size(); dep1++) {
+  auto nodesObj = nodes.at(dep1);
+  std::string nodesObjStr = std::string("Nodes") + "." + std::to_string(dep1 + 1);
+    setParameter(nodesObjStr + ".IpAddress", nodesObj.ipAddress);
+    setParameter(nodesObjStr + ".HostName", nodesObj.hostName);
+    setParameter(nodesObjStr + ".Role", nodesObj.role);
+    setParameter(nodesObjStr + ".SchedulerType", nodesObj.schedulerType);
+    setParameter(nodesObjStr + ".AccountType", nodesObj.accountType);
+    setParameter(nodesObjStr + ".Dir", nodesObj.dir);
+  }
+}
+
+std::vector<CreateHybridClusterRequest::Application> CreateHybridClusterRequest::getApplication() const {
+  return application_;
+}
+
+void CreateHybridClusterRequest::setApplication(const std::vector<CreateHybridClusterRequest::Application> &application) {
+  application_ = application;
+  for(int dep1 = 0; dep1 != application.size(); dep1++) {
+  auto applicationObj = application.at(dep1);
+  std::string applicationObjStr = std::string("Application") + "." + std::to_string(dep1 + 1);
+    setParameter(applicationObjStr + ".Tag", applicationObj.tag);
+  }
+}
+
+std::string CreateHybridClusterRequest::getVpcId() const {
+  return vpcId_;
+}
+
+void CreateHybridClusterRequest::setVpcId(const std::string &vpcId) {
+  vpcId_ = vpcId;
+  setParameter(std::string("VpcId"), vpcId);
+}
+
+std::string CreateHybridClusterRequest::getVolumeMountpoint() const {
+  return volumeMountpoint_;
+}
+
+void CreateHybridClusterRequest::setVolumeMountpoint(const std::string &volumeMountpoint) {
+  volumeMountpoint_ = volumeMountpoint;
+  setParameter(std::string("VolumeMountpoint"), volumeMountpoint);
+}
+
+bool CreateHybridClusterRequest::getSchedulerPreInstall() const {
+  return schedulerPreInstall_;
+}
+
+void CreateHybridClusterRequest::setSchedulerPreInstall(bool schedulerPreInstall) {
+  schedulerPreInstall_ = schedulerPreInstall;
+  setParameter(std::string("SchedulerPreInstall"), schedulerPreInstall ? "true" : "false");
+}
+
+std::string CreateHybridClusterRequest::getLocation() const {
+  return location_;
+}
+
+void CreateHybridClusterRequest::setLocation(const std::string &location) {
+  location_ = location;
+  setParameter(std::string("Location"), location);
+}
+

ehpc/src/model/CreateHybridClusterResult.cc

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

ehpc/src/model/CreateJobFileRequest.cc

@@ -0,0 +1,81 @@
+/*
+ * 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/ehpc/model/CreateJobFileRequest.h>
+
+using AlibabaCloud::EHPC::Model::CreateJobFileRequest;
+
+CreateJobFileRequest::CreateJobFileRequest()
+    : RpcServiceRequest("ehpc", "2018-04-12", "CreateJobFile") {
+  setMethod(HttpRequest::Method::Get);
+}
+
+CreateJobFileRequest::~CreateJobFileRequest() {}
+
+std::string CreateJobFileRequest::getTargetFile() const {
+  return targetFile_;
+}
+
+void CreateJobFileRequest::setTargetFile(const std::string &targetFile) {
+  targetFile_ = targetFile;
+  setParameter(std::string("TargetFile"), targetFile);
+}
+
+std::string CreateJobFileRequest::getRunasUserPassword() const {
+  return runasUserPassword_;
+}
+
+void CreateJobFileRequest::setRunasUserPassword(const std::string &runasUserPassword) {
+  runasUserPassword_ = runasUserPassword;
+  setParameter(std::string("RunasUserPassword"), runasUserPassword);
+}
+
+std::string CreateJobFileRequest::getRunasUser() const {
+  return runasUser_;
+}
+
+void CreateJobFileRequest::setRunasUser(const std::string &runasUser) {
+  runasUser_ = runasUser;
+  setParameter(std::string("RunasUser"), runasUser);
+}
+
+std::string CreateJobFileRequest::getClusterId() const {
+  return clusterId_;
+}
+
+void CreateJobFileRequest::setClusterId(const std::string &clusterId) {
+  clusterId_ = clusterId;
+  setParameter(std::string("ClusterId"), clusterId);
+}
+
+std::string CreateJobFileRequest::getContent() const {
+  return content_;
+}
+
+void CreateJobFileRequest::setContent(const std::string &content) {
+  content_ = content;
+  setParameter(std::string("Content"), content);
+}
+
+std::string CreateJobFileRequest::getAccessKeyId() const {
+  return accessKeyId_;
+}
+
+void CreateJobFileRequest::setAccessKeyId(const std::string &accessKeyId) {
+  accessKeyId_ = accessKeyId;
+  setParameter(std::string("AccessKeyId"), accessKeyId);
+}
+

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

ehpc/src/model/CreateJobTemplateRequest.cc

@@ -19,7 +19,7 @@
 using AlibabaCloud::EHPC::Model::CreateJobTemplateRequest;
 
 CreateJobTemplateRequest::CreateJobTemplateRequest()
-    : RpcServiceRequest("ehpc", "2017-07-14", "CreateJobTemplate") {
+    : RpcServiceRequest("ehpc", "2018-04-12", "CreateJobTemplate") {
   setMethod(HttpRequest::Method::Get);
 }
 
@@ -34,6 +34,15 @@ void CreateJobTemplateRequest::setStderrRedirectPath(const std::string &stderrRe
   setParameter(std::string("StderrRedirectPath"), stderrRedirectPath);
 }
 
+std::string CreateJobTemplateRequest::getClockTime() const {
+  return clockTime_;
+}
+
+void CreateJobTemplateRequest::setClockTime(const std::string &clockTime) {
+  clockTime_ = clockTime;
+  setParameter(std::string("ClockTime"), clockTime);
+}
+
 std::string CreateJobTemplateRequest::getCommandLine() const {
   return commandLine_;
 }
@@ -61,6 +70,15 @@ void CreateJobTemplateRequest::setArrayRequest(const std::string &arrayRequest)
   setParameter(std::string("ArrayRequest"), arrayRequest);
 }
 
+std::string CreateJobTemplateRequest::getUnzipCmd() const {
+  return unzipCmd_;
+}
+
+void CreateJobTemplateRequest::setUnzipCmd(const std::string &unzipCmd) {
+  unzipCmd_ = unzipCmd;
+  setParameter(std::string("UnzipCmd"), unzipCmd);
+}
+
 std::string CreateJobTemplateRequest::getPackagePath() const {
   return packagePath_;
 }
@@ -70,13 +88,13 @@ void CreateJobTemplateRequest::setPackagePath(const std::string &packagePath) {
   setParameter(std::string("PackagePath"), packagePath);
 }
 
-std::string CreateJobTemplateRequest::getRegionId() const {
-  return regionId_;
+std::string CreateJobTemplateRequest::getMem() const {
+  return mem_;
 }
 
-void CreateJobTemplateRequest::setRegionId(const std::string &regionId) {
-  regionId_ = regionId;
-  setParameter(std::string("RegionId"), regionId);
+void CreateJobTemplateRequest::setMem(const std::string &mem) {
+  mem_ = mem;
+  setParameter(std::string("Mem"), mem);
 }
 
 std::string CreateJobTemplateRequest::getStdoutRedirectPath() const {
@@ -115,6 +133,15 @@ void CreateJobTemplateRequest::setReRunable(bool reRunable) {
   setParameter(std::string("ReRunable"), reRunable ? "true" : "false");
 }
 
+int CreateJobTemplateRequest::getThread() const {
+  return thread_;
+}
+
+void CreateJobTemplateRequest::setThread(int thread) {
+  thread_ = thread;
+  setParameter(std::string("Thread"), std::to_string(thread));
+}
+
 int CreateJobTemplateRequest::getPriority() const {
   return priority_;
 }
@@ -124,6 +151,51 @@ void CreateJobTemplateRequest::setPriority(int priority) {
   setParameter(std::string("Priority"), std::to_string(priority));
 }
 
+int CreateJobTemplateRequest::getGpu() const {
+  return gpu_;
+}
+
+void CreateJobTemplateRequest::setGpu(int gpu) {
+  gpu_ = gpu;
+  setParameter(std::string("Gpu"), std::to_string(gpu));
+}
+
+bool CreateJobTemplateRequest::getWithUnzipCmd() const {
+  return withUnzipCmd_;
+}
+
+void CreateJobTemplateRequest::setWithUnzipCmd(bool withUnzipCmd) {
+  withUnzipCmd_ = withUnzipCmd;
+  setParameter(std::string("WithUnzipCmd"), withUnzipCmd ? "true" : "false");
+}
+
+int CreateJobTemplateRequest::getNode() const {
+  return node_;
+}
+
+void CreateJobTemplateRequest::setNode(int node) {
+  node_ = node;
+  setParameter(std::string("Node"), std::to_string(node));
+}
+
+int CreateJobTemplateRequest::getTask() const {
+  return task_;
+}
+
+void CreateJobTemplateRequest::setTask(int task) {
+  task_ = task;
+  setParameter(std::string("Task"), std::to_string(task));
+}
+
+std::string CreateJobTemplateRequest::getInputFileUrl() const {
+  return inputFileUrl_;
+}
+
+void CreateJobTemplateRequest::setInputFileUrl(const std::string &inputFileUrl) {
+  inputFileUrl_ = inputFileUrl;
+  setParameter(std::string("InputFileUrl"), inputFileUrl);
+}
+
 std::string CreateJobTemplateRequest::getName() const {
   return name_;
 }
@@ -133,3 +205,12 @@ void CreateJobTemplateRequest::setName(const std::string &name) {
   setParameter(std::string("Name"), name);
 }
 
+std::string CreateJobTemplateRequest::getQueue() const {
+  return queue_;
+}
+
+void CreateJobTemplateRequest::setQueue(const std::string &queue) {
+  queue_ = queue;
+  setParameter(std::string("Queue"), queue);
+}
+

ehpc/src/model/DeleteClusterRequest.cc

@@ -19,7 +19,7 @@
 using AlibabaCloud::EHPC::Model::DeleteClusterRequest;
 
 DeleteClusterRequest::DeleteClusterRequest()
-    : RpcServiceRequest("ehpc", "2017-07-14", "DeleteCluster") {
+    : RpcServiceRequest("ehpc", "2018-04-12", "DeleteCluster") {
   setMethod(HttpRequest::Method::Get);
 }
 

ehpc/src/model/DeleteClusterResult.cc

@@ -39,6 +39,13 @@ void DeleteClusterResult::parse(const std::string &payload)
 	Json::Value value;
 	reader.parse(payload, value);
 	setRequestId(value["RequestId"].asString());
+	if(!value["TaskId"].isNull())
+		taskId_ = value["TaskId"].asString();
 
 }
 
+std::string DeleteClusterResult::getTaskId()const
+{
+	return taskId_;
+}
+

ehpc/src/model/DeleteContainerAppsRequest.cc

@@ -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.
+ */
+
+#include <alibabacloud/ehpc/model/DeleteContainerAppsRequest.h>
+
+using AlibabaCloud::EHPC::Model::DeleteContainerAppsRequest;
+
+DeleteContainerAppsRequest::DeleteContainerAppsRequest()
+    : RpcServiceRequest("ehpc", "2018-04-12", "DeleteContainerApps") {
+  setMethod(HttpRequest::Method::Get);
+}
+
+DeleteContainerAppsRequest::~DeleteContainerAppsRequest() {}
+
+std::vector<DeleteContainerAppsRequest::ContainerApp> DeleteContainerAppsRequest::getContainerApp() const {
+  return containerApp_;
+}
+
+void DeleteContainerAppsRequest::setContainerApp(const std::vector<DeleteContainerAppsRequest::ContainerApp> &containerApp) {
+  containerApp_ = containerApp;
+  for(int dep1 = 0; dep1 != containerApp.size(); dep1++) {
+  auto containerAppObj = containerApp.at(dep1);
+  std::string containerAppObjStr = std::string("ContainerApp") + "." + std::to_string(dep1 + 1);
+    setParameter(containerAppObjStr + ".Id", containerAppObj.id);
+  }
+}
+
+std::string DeleteContainerAppsRequest::getAccessKeyId() const {
+  return accessKeyId_;
+}
+
+void DeleteContainerAppsRequest::setAccessKeyId(const std::string &accessKeyId) {
+  accessKeyId_ = accessKeyId;
+  setParameter(std::string("AccessKeyId"), accessKeyId);
+}
+

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

ehpc/src/model/DeleteGWSClusterRequest.cc

@@ -0,0 +1,45 @@
+/*
+ * 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/ehpc/model/DeleteGWSClusterRequest.h>
+
+using AlibabaCloud::EHPC::Model::DeleteGWSClusterRequest;
+
+DeleteGWSClusterRequest::DeleteGWSClusterRequest()
+    : RpcServiceRequest("ehpc", "2018-04-12", "DeleteGWSCluster") {
+  setMethod(HttpRequest::Method::Get);
+}
+
+DeleteGWSClusterRequest::~DeleteGWSClusterRequest() {}
+
+std::string DeleteGWSClusterRequest::getClusterId() const {
+  return clusterId_;
+}
+
+void DeleteGWSClusterRequest::setClusterId(const std::string &clusterId) {
+  clusterId_ = clusterId;
+  setParameter(std::string("ClusterId"), clusterId);
+}
+
+std::string DeleteGWSClusterRequest::getAccessKeyId() const {
+  return accessKeyId_;
+}
+
+void DeleteGWSClusterRequest::setAccessKeyId(const std::string &accessKeyId) {
+  accessKeyId_ = accessKeyId;
+  setParameter(std::string("AccessKeyId"), accessKeyId);
+}
+

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

ehpc/src/model/DeleteGWSInstanceRequest.cc

@@ -0,0 +1,45 @@
+/*
+ * 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/ehpc/model/DeleteGWSInstanceRequest.h>
+
+using AlibabaCloud::EHPC::Model::DeleteGWSInstanceRequest;
+
+DeleteGWSInstanceRequest::DeleteGWSInstanceRequest()
+    : RpcServiceRequest("ehpc", "2018-04-12", "DeleteGWSInstance") {
+  setMethod(HttpRequest::Method::Get);
+}
+
+DeleteGWSInstanceRequest::~DeleteGWSInstanceRequest() {}
+
+std::string DeleteGWSInstanceRequest::getAccessKeyId() const {
+  return accessKeyId_;
+}
+
+void DeleteGWSInstanceRequest::setAccessKeyId(const std::string &accessKeyId) {
+  accessKeyId_ = accessKeyId;
+  setParameter(std::string("AccessKeyId"), accessKeyId);
+}
+
+std::string DeleteGWSInstanceRequest::getInstanceId() const {
+  return instanceId_;
+}
+
+void DeleteGWSInstanceRequest::setInstanceId(const std::string &instanceId) {
+  instanceId_ = instanceId;
+  setParameter(std::string("InstanceId"), instanceId);
+}
+

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

ehpc/src/model/DeleteImageRequest.cc

@@ -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.
+ */
+
+#include <alibabacloud/ehpc/model/DeleteImageRequest.h>
+
+using AlibabaCloud::EHPC::Model::DeleteImageRequest;
+
+DeleteImageRequest::DeleteImageRequest()
+    : RpcServiceRequest("ehpc", "2018-04-12", "DeleteImage") {
+  setMethod(HttpRequest::Method::Get);
+}
+
+DeleteImageRequest::~DeleteImageRequest() {}
+
+std::string DeleteImageRequest::getClusterId() const {
+  return clusterId_;
+}
+
+void DeleteImageRequest::setClusterId(const std::string &clusterId) {
+  clusterId_ = clusterId;
+  setParameter(std::string("ClusterId"), clusterId);
+}
+
+std::string DeleteImageRequest::getRepository() const {
+  return repository_;
+}
+
+void DeleteImageRequest::setRepository(const std::string &repository) {
+  repository_ = repository;
+  setParameter(std::string("Repository"), repository);
+}
+
+std::string DeleteImageRequest::getAccessKeyId() const {
+  return accessKeyId_;
+}
+
+void DeleteImageRequest::setAccessKeyId(const std::string &accessKeyId) {
+  accessKeyId_ = accessKeyId;
+  setParameter(std::string("AccessKeyId"), accessKeyId);
+}
+
+std::string DeleteImageRequest::getContainerType() const {
+  return containerType_;
+}
+
+void DeleteImageRequest::setContainerType(const std::string &containerType) {
+  containerType_ = containerType;
+  setParameter(std::string("ContainerType"), containerType);
+}
+
+std::string DeleteImageRequest::getImageTag() const {
+  return imageTag_;
+}
+
+void DeleteImageRequest::setImageTag(const std::string &imageTag) {
+  imageTag_ = imageTag;
+  setParameter(std::string("ImageTag"), imageTag);
+}
+

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

ehpc/src/model/DeleteJobTemplatesRequest.cc

@@ -19,7 +19,7 @@
 using AlibabaCloud::EHPC::Model::DeleteJobTemplatesRequest;
 
 DeleteJobTemplatesRequest::DeleteJobTemplatesRequest()
-    : RpcServiceRequest("ehpc", "2017-07-14", "DeleteJobTemplates") {
+    : RpcServiceRequest("ehpc", "2018-04-12", "DeleteJobTemplates") {
   setMethod(HttpRequest::Method::Get);
 }
 
@@ -43,12 +43,3 @@ void DeleteJobTemplatesRequest::setAccessKeyId(const std::string &accessKeyId) {
   setParameter(std::string("AccessKeyId"), accessKeyId);
 }
 
-std::string DeleteJobTemplatesRequest::getRegionId() const {
-  return regionId_;
-}
-
-void DeleteJobTemplatesRequest::setRegionId(const std::string &regionId) {
-  regionId_ = regionId;
-  setParameter(std::string("RegionId"), regionId);
-}
-

ehpc/src/model/DeleteJobsRequest.cc

@@ -19,7 +19,7 @@
 using AlibabaCloud::EHPC::Model::DeleteJobsRequest;
 
 DeleteJobsRequest::DeleteJobsRequest()
-    : RpcServiceRequest("ehpc", "2017-07-14", "DeleteJobs") {
+    : RpcServiceRequest("ehpc", "2018-04-12", "DeleteJobs") {
   setMethod(HttpRequest::Method::Get);
 }
 

ehpc/src/model/DeleteLocalImageRequest.cc

@@ -0,0 +1,54 @@
+/*
+ * 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/ehpc/model/DeleteLocalImageRequest.h>
+
+using AlibabaCloud::EHPC::Model::DeleteLocalImageRequest;
+
+DeleteLocalImageRequest::DeleteLocalImageRequest()
+    : RpcServiceRequest("ehpc", "2018-04-12", "DeleteLocalImage") {
+  setMethod(HttpRequest::Method::Get);
+}
+
+DeleteLocalImageRequest::~DeleteLocalImageRequest() {}
+
+std::string DeleteLocalImageRequest::getClusterId() const {
+  return clusterId_;
+}
+
+void DeleteLocalImageRequest::setClusterId(const std::string &clusterId) {
+  clusterId_ = clusterId;
+  setParameter(std::string("ClusterId"), clusterId);
+}
+
+std::string DeleteLocalImageRequest::getContainerType() const {
+  return containerType_;
+}
+
+void DeleteLocalImageRequest::setContainerType(const std::string &containerType) {
+  containerType_ = containerType;
+  setParameter(std::string("ContainerType"), containerType);
+}
+
+std::string DeleteLocalImageRequest::getImageName() const {
+  return imageName_;
+}
+
+void DeleteLocalImageRequest::setImageName(const std::string &imageName) {
+  imageName_ = imageName;
+  setParameter(std::string("ImageName"), imageName);
+}
+

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

ehpc/src/model/DeleteNodesRequest.cc

@@ -19,7 +19,7 @@
 using AlibabaCloud::EHPC::Model::DeleteNodesRequest;
 
 DeleteNodesRequest::DeleteNodesRequest()
-    : RpcServiceRequest("ehpc", "2017-07-14", "DeleteNodes") {
+    : RpcServiceRequest("ehpc", "2018-04-12", "DeleteNodes") {
   setMethod(HttpRequest::Method::Get);
 }
 
@@ -47,6 +47,15 @@ void DeleteNodesRequest::setClusterId(const std::string &clusterId) {
   setParameter(std::string("ClusterId"), clusterId);
 }
 
+bool DeleteNodesRequest::getSync() const {
+  return sync_;
+}
+
+void DeleteNodesRequest::setSync(bool sync) {
+  sync_ = sync;
+  setParameter(std::string("Sync"), sync ? "true" : "false");
+}
+
 std::string DeleteNodesRequest::getAccessKeyId() const {
   return accessKeyId_;
 }

ehpc/src/model/DeleteNodesResult.cc

@@ -39,6 +39,13 @@ void DeleteNodesResult::parse(const std::string &payload)
 	Json::Value value;
 	reader.parse(payload, value);
 	setRequestId(value["RequestId"].asString());
+	if(!value["TaskId"].isNull())
+		taskId_ = value["TaskId"].asString();
 
 }
 
+std::string DeleteNodesResult::getTaskId()const
+{
+	return taskId_;
+}
+

ehpc/src/model/DeleteQueueRequest.cc

@@ -0,0 +1,54 @@
+/*
+ * 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/ehpc/model/DeleteQueueRequest.h>
+
+using AlibabaCloud::EHPC::Model::DeleteQueueRequest;
+
+DeleteQueueRequest::DeleteQueueRequest()
+    : RpcServiceRequest("ehpc", "2018-04-12", "DeleteQueue") {
+  setMethod(HttpRequest::Method::Get);
+}
+
+DeleteQueueRequest::~DeleteQueueRequest() {}
+
+std::string DeleteQueueRequest::getQueueName() const {
+  return queueName_;
+}
+
+void DeleteQueueRequest::setQueueName(const std::string &queueName) {
+  queueName_ = queueName;
+  setParameter(std::string("QueueName"), queueName);
+}
+
+std::string DeleteQueueRequest::getClusterId() const {
+  return clusterId_;
+}
+
+void DeleteQueueRequest::setClusterId(const std::string &clusterId) {
+  clusterId_ = clusterId;
+  setParameter(std::string("ClusterId"), clusterId);
+}
+
+std::string DeleteQueueRequest::getAccessKeyId() const {
+  return accessKeyId_;
+}
+
+void DeleteQueueRequest::setAccessKeyId(const std::string &accessKeyId) {
+  accessKeyId_ = accessKeyId;
+  setParameter(std::string("AccessKeyId"), accessKeyId);
+}
+

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

ehpc/src/model/DeleteSecurityGroupRequest.cc

@@ -0,0 +1,54 @@
+/*
+ * 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/ehpc/model/DeleteSecurityGroupRequest.h>
+
+using AlibabaCloud::EHPC::Model::DeleteSecurityGroupRequest;
+
+DeleteSecurityGroupRequest::DeleteSecurityGroupRequest()
+    : RpcServiceRequest("ehpc", "2018-04-12", "DeleteSecurityGroup") {
+  setMethod(HttpRequest::Method::Get);
+}
+
+DeleteSecurityGroupRequest::~DeleteSecurityGroupRequest() {}
+
+std::string DeleteSecurityGroupRequest::getSecurityGroupId() const {
+  return securityGroupId_;
+}
+
+void DeleteSecurityGroupRequest::setSecurityGroupId(const std::string &securityGroupId) {
+  securityGroupId_ = securityGroupId;
+  setParameter(std::string("SecurityGroupId"), securityGroupId);
+}
+
+std::string DeleteSecurityGroupRequest::getClusterId() const {
+  return clusterId_;
+}
+
+void DeleteSecurityGroupRequest::setClusterId(const std::string &clusterId) {
+  clusterId_ = clusterId;
+  setParameter(std::string("ClusterId"), clusterId);
+}
+
+std::string DeleteSecurityGroupRequest::getAccessKeyId() const {
+  return accessKeyId_;
+}
+
+void DeleteSecurityGroupRequest::setAccessKeyId(const std::string &accessKeyId) {
+  accessKeyId_ = accessKeyId;
+  setParameter(std::string("AccessKeyId"), accessKeyId);
+}
+

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

ehpc/src/model/DeleteUsersRequest.cc

@@ -19,7 +19,7 @@
 using AlibabaCloud::EHPC::Model::DeleteUsersRequest;
 
 DeleteUsersRequest::DeleteUsersRequest()
-    : RpcServiceRequest("ehpc", "2017-07-14", "DeleteUsers") {
+    : RpcServiceRequest("ehpc", "2018-04-12", "DeleteUsers") {
   setMethod(HttpRequest::Method::Get);
 }
 

ehpc/src/model/DescribeAutoScaleConfigRequest.cc

@@ -0,0 +1,45 @@
+/*
+ * 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/ehpc/model/DescribeAutoScaleConfigRequest.h>
+
+using AlibabaCloud::EHPC::Model::DescribeAutoScaleConfigRequest;
+
+DescribeAutoScaleConfigRequest::DescribeAutoScaleConfigRequest()
+    : RpcServiceRequest("ehpc", "2018-04-12", "DescribeAutoScaleConfig") {
+  setMethod(HttpRequest::Method::Get);
+}
+
+DescribeAutoScaleConfigRequest::~DescribeAutoScaleConfigRequest() {}
+
+std::string DescribeAutoScaleConfigRequest::getClusterId() const {
+  return clusterId_;
+}
+
+void DescribeAutoScaleConfigRequest::setClusterId(const std::string &clusterId) {
+  clusterId_ = clusterId;
+  setParameter(std::string("ClusterId"), clusterId);
+}
+
+std::string DescribeAutoScaleConfigRequest::getAccessKeyId() const {
+  return accessKeyId_;
+}
+
+void DescribeAutoScaleConfigRequest::setAccessKeyId(const std::string &accessKeyId) {
+  accessKeyId_ = accessKeyId;
+  setParameter(std::string("AccessKeyId"), accessKeyId);
+}
+

ehpc/src/model/DescribeAutoScaleConfigResult.cc

@@ -0,0 +1,149 @@
+/*
+ * 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/ehpc/model/DescribeAutoScaleConfigResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::EHPC;
+using namespace AlibabaCloud::EHPC::Model;
+
+DescribeAutoScaleConfigResult::DescribeAutoScaleConfigResult() :
+	ServiceResult()
+{}
+
+DescribeAutoScaleConfigResult::DescribeAutoScaleConfigResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+DescribeAutoScaleConfigResult::~DescribeAutoScaleConfigResult()
+{}
+
+void DescribeAutoScaleConfigResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	if(!value["MaxNodesInCluster"].isNull())
+		maxNodesInCluster_ = std::stoi(value["MaxNodesInCluster"].asString());
+	if(!value["GrowTimeoutInMinutes"].isNull())
+		growTimeoutInMinutes_ = std::stoi(value["GrowTimeoutInMinutes"].asString());
+	if(!value["SpotStrategy"].isNull())
+		spotStrategy_ = value["SpotStrategy"].asString();
+	if(!value["EnableAutoShrink"].isNull())
+		enableAutoShrink_ = value["EnableAutoShrink"].asString() == "true";
+	if(!value["ClusterType"].isNull())
+		clusterType_ = value["ClusterType"].asString();
+	if(!value["EnableAutoGrow"].isNull())
+		enableAutoGrow_ = value["EnableAutoGrow"].asString() == "true";
+	if(!value["ExcludeNodes"].isNull())
+		excludeNodes_ = value["ExcludeNodes"].asString();
+	if(!value["GrowIntervalInMinutes"].isNull())
+		growIntervalInMinutes_ = std::stoi(value["GrowIntervalInMinutes"].asString());
+	if(!value["ShrinkIntervalInMinutes"].isNull())
+		shrinkIntervalInMinutes_ = std::stoi(value["ShrinkIntervalInMinutes"].asString());
+	if(!value["SpotPriceLimit"].isNull())
+		spotPriceLimit_ = value["SpotPriceLimit"].asString();
+	if(!value["ShrinkIdleTimes"].isNull())
+		shrinkIdleTimes_ = std::stoi(value["ShrinkIdleTimes"].asString());
+	if(!value["ExtraNodesGrowRatio"].isNull())
+		extraNodesGrowRatio_ = std::stoi(value["ExtraNodesGrowRatio"].asString());
+	if(!value["GrowRatio"].isNull())
+		growRatio_ = std::stoi(value["GrowRatio"].asString());
+	if(!value["Uid"].isNull())
+		uid_ = value["Uid"].asString();
+	if(!value["ClusterId"].isNull())
+		clusterId_ = value["ClusterId"].asString();
+
+}
+
+int DescribeAutoScaleConfigResult::getExtraNodesGrowRatio()const
+{
+	return extraNodesGrowRatio_;
+}
+
+bool DescribeAutoScaleConfigResult::getEnableAutoGrow()const
+{
+	return enableAutoGrow_;
+}
+
+std::string DescribeAutoScaleConfigResult::getClusterId()const
+{
+	return clusterId_;
+}
+
+int DescribeAutoScaleConfigResult::getMaxNodesInCluster()const
+{
+	return maxNodesInCluster_;
+}
+
+int DescribeAutoScaleConfigResult::getShrinkIdleTimes()const
+{
+	return shrinkIdleTimes_;
+}
+
+bool DescribeAutoScaleConfigResult::getEnableAutoShrink()const
+{
+	return enableAutoShrink_;
+}
+
+std::string DescribeAutoScaleConfigResult::getClusterType()const
+{
+	return clusterType_;
+}
+
+int DescribeAutoScaleConfigResult::getGrowRatio()const
+{
+	return growRatio_;
+}
+
+int DescribeAutoScaleConfigResult::getGrowIntervalInMinutes()const
+{
+	return growIntervalInMinutes_;
+}
+
+std::string DescribeAutoScaleConfigResult::getUid()const
+{
+	return uid_;
+}
+
+int DescribeAutoScaleConfigResult::getGrowTimeoutInMinutes()const
+{
+	return growTimeoutInMinutes_;
+}
+
+int DescribeAutoScaleConfigResult::getShrinkIntervalInMinutes()const
+{
+	return shrinkIntervalInMinutes_;
+}
+
+std::string DescribeAutoScaleConfigResult::getSpotPriceLimit()const
+{
+	return spotPriceLimit_;
+}
+
+std::string DescribeAutoScaleConfigResult::getExcludeNodes()const
+{
+	return excludeNodes_;
+}
+
+std::string DescribeAutoScaleConfigResult::getSpotStrategy()const
+{
+	return spotStrategy_;
+}
+

ehpc/src/model/DescribeClusterRequest.cc

@@ -19,7 +19,7 @@
 using AlibabaCloud::EHPC::Model::DescribeClusterRequest;
 
 DescribeClusterRequest::DescribeClusterRequest()
-    : RpcServiceRequest("ehpc", "2017-07-14", "DescribeCluster") {
+    : RpcServiceRequest("ehpc", "2018-04-12", "DescribeCluster") {
   setMethod(HttpRequest::Method::Get);
 }
 

ehpc/src/model/DescribeClusterResult.cc

@@ -42,46 +42,56 @@ void DescribeClusterResult::parse(const std::string &payload)
 	auto clusterInfoNode = value["ClusterInfo"];
 	if(!clusterInfoNode["Status"].isNull())
 		clusterInfo_.status = clusterInfoNode["Status"].asString();
-	if(!clusterInfoNode["SchedulerType"].isNull())
-		clusterInfo_.schedulerType = clusterInfoNode["SchedulerType"].asString();
+	if(!clusterInfoNode["VpcId"].isNull())
+		clusterInfo_.vpcId = clusterInfoNode["VpcId"].asString();
 	if(!clusterInfoNode["KeyPairName"].isNull())
 		clusterInfo_.keyPairName = clusterInfoNode["KeyPairName"].asString();
 	if(!clusterInfoNode["EcsChargeType"].isNull())
 		clusterInfo_.ecsChargeType = clusterInfoNode["EcsChargeType"].asString();
-	if(!clusterInfoNode["SccClusterId"].isNull())
-		clusterInfo_.sccClusterId = clusterInfoNode["SccClusterId"].asString();
 	if(!clusterInfoNode["SecurityGroupId"].isNull())
 		clusterInfo_.securityGroupId = clusterInfoNode["SecurityGroupId"].asString();
+	if(!clusterInfoNode["SccClusterId"].isNull())
+		clusterInfo_.sccClusterId = clusterInfoNode["SccClusterId"].asString();
 	if(!clusterInfoNode["CreateTime"].isNull())
 		clusterInfo_.createTime = clusterInfoNode["CreateTime"].asString();
-	if(!clusterInfoNode["ImageOwnerAlias"].isNull())
-		clusterInfo_.imageOwnerAlias = clusterInfoNode["ImageOwnerAlias"].asString();
-	if(!clusterInfoNode["RemoteDirectory"].isNull())
-		clusterInfo_.remoteDirectory = clusterInfoNode["RemoteDirectory"].asString();
-	if(!clusterInfoNode["VolumeMountpoint"].isNull())
-		clusterInfo_.volumeMountpoint = clusterInfoNode["VolumeMountpoint"].asString();
-	if(!clusterInfoNode["OsTag"].isNull())
-		clusterInfo_.osTag = clusterInfoNode["OsTag"].asString();
 	if(!clusterInfoNode["AccountType"].isNull())
 		clusterInfo_.accountType = clusterInfoNode["AccountType"].asString();
 	if(!clusterInfoNode["VolumeProtocol"].isNull())
 		clusterInfo_.volumeProtocol = clusterInfoNode["VolumeProtocol"].asString();
-	if(!clusterInfoNode["RegionId"].isNull())
-		clusterInfo_.regionId = clusterInfoNode["RegionId"].asString();
-	if(!clusterInfoNode["VSwitchId"].isNull())
-		clusterInfo_.vSwitchId = clusterInfoNode["VSwitchId"].asString();
 	if(!clusterInfoNode["Description"].isNull())
 		clusterInfo_.description = clusterInfoNode["Description"].asString();
 	if(!clusterInfoNode["VolumeId"].isNull())
 		clusterInfo_.volumeId = clusterInfoNode["VolumeId"].asString();
 	if(!clusterInfoNode["HaEnable"].isNull())
 		clusterInfo_.haEnable = clusterInfoNode["HaEnable"].asString() == "true";
+	if(!clusterInfoNode["BaseOsTag"].isNull())
+		clusterInfo_.baseOsTag = clusterInfoNode["BaseOsTag"].asString();
 	if(!clusterInfoNode["Name"].isNull())
 		clusterInfo_.name = clusterInfoNode["Name"].asString();
 	if(!clusterInfoNode["ImageId"].isNull())
 		clusterInfo_.imageId = clusterInfoNode["ImageId"].asString();
+	if(!clusterInfoNode["SchedulerType"].isNull())
+		clusterInfo_.schedulerType = clusterInfoNode["SchedulerType"].asString();
+	if(!clusterInfoNode["DeployMode"].isNull())
+		clusterInfo_.deployMode = clusterInfoNode["DeployMode"].asString();
+	if(!clusterInfoNode["ImageOwnerAlias"].isNull())
+		clusterInfo_.imageOwnerAlias = clusterInfoNode["ImageOwnerAlias"].asString();
+	if(!clusterInfoNode["OsTag"].isNull())
+		clusterInfo_.osTag = clusterInfoNode["OsTag"].asString();
+	if(!clusterInfoNode["VolumeMountpoint"].isNull())
+		clusterInfo_.volumeMountpoint = clusterInfoNode["VolumeMountpoint"].asString();
+	if(!clusterInfoNode["RemoteDirectory"].isNull())
+		clusterInfo_.remoteDirectory = clusterInfoNode["RemoteDirectory"].asString();
+	if(!clusterInfoNode["RegionId"].isNull())
+		clusterInfo_.regionId = clusterInfoNode["RegionId"].asString();
+	if(!clusterInfoNode["VSwitchId"].isNull())
+		clusterInfo_.vSwitchId = clusterInfoNode["VSwitchId"].asString();
+	if(!clusterInfoNode["ImageName"].isNull())
+		clusterInfo_.imageName = clusterInfoNode["ImageName"].asString();
 	if(!clusterInfoNode["VolumeType"].isNull())
 		clusterInfo_.volumeType = clusterInfoNode["VolumeType"].asString();
+	if(!clusterInfoNode["Location"].isNull())
+		clusterInfo_.location = clusterInfoNode["Location"].asString();
 	if(!clusterInfoNode["Id"].isNull())
 		clusterInfo_.id = clusterInfoNode["Id"].asString();
 	if(!clusterInfoNode["ClientVersion"].isNull())
@@ -98,6 +108,28 @@ void DescribeClusterResult::parse(const std::string &payload)
 			applicationInfoObject.version = clusterInfoNodeApplicationsApplicationInfo["Version"].asString();
 		clusterInfo_.applications.push_back(applicationInfoObject);
 	}
+	auto allPostInstallScriptsNode = clusterInfoNode["PostInstallScripts"]["PostInstallScriptInfo"];
+	for (auto clusterInfoNodePostInstallScriptsPostInstallScriptInfo : allPostInstallScriptsNode)
+	{
+		ClusterInfo::PostInstallScriptInfo postInstallScriptInfoObject;
+		if(!clusterInfoNodePostInstallScriptsPostInstallScriptInfo["Url"].isNull())
+			postInstallScriptInfoObject.url = clusterInfoNodePostInstallScriptsPostInstallScriptInfo["Url"].asString();
+		if(!clusterInfoNodePostInstallScriptsPostInstallScriptInfo["Args"].isNull())
+			postInstallScriptInfoObject.args = clusterInfoNodePostInstallScriptsPostInstallScriptInfo["Args"].asString();
+		clusterInfo_.postInstallScripts.push_back(postInstallScriptInfoObject);
+	}
+	auto allOnPremiseInfoNode = clusterInfoNode["OnPremiseInfo"]["OnPremiseInfoItem"];
+	for (auto clusterInfoNodeOnPremiseInfoOnPremiseInfoItem : allOnPremiseInfoNode)
+	{
+		ClusterInfo::OnPremiseInfoItem onPremiseInfoItemObject;
+		if(!clusterInfoNodeOnPremiseInfoOnPremiseInfoItem["Type"].isNull())
+			onPremiseInfoItemObject.type = clusterInfoNodeOnPremiseInfoOnPremiseInfoItem["Type"].asString();
+		if(!clusterInfoNodeOnPremiseInfoOnPremiseInfoItem["HostName"].isNull())
+			onPremiseInfoItemObject.hostName = clusterInfoNodeOnPremiseInfoOnPremiseInfoItem["HostName"].asString();
+		if(!clusterInfoNodeOnPremiseInfoOnPremiseInfoItem["IP"].isNull())
+			onPremiseInfoItemObject.iP = clusterInfoNodeOnPremiseInfoOnPremiseInfoItem["IP"].asString();
+		clusterInfo_.onPremiseInfo.push_back(onPremiseInfoItemObject);
+	}
 	auto ecsInfoNode = clusterInfoNode["EcsInfo"];
 	auto managerNode = ecsInfoNode["Manager"];
 	if(!managerNode["InstanceType"].isNull())
@@ -114,6 +146,11 @@ void DescribeClusterResult::parse(const std::string &payload)
 		clusterInfo_.ecsInfo.login.instanceType = loginNode["InstanceType"].asString();
 	if(!loginNode["Count"].isNull())
 		clusterInfo_.ecsInfo.login.count = std::stoi(loginNode["Count"].asString());
+	auto proxyMgrNode = ecsInfoNode["ProxyMgr"];
+	if(!proxyMgrNode["InstanceType"].isNull())
+		clusterInfo_.ecsInfo.proxyMgr.instanceType = proxyMgrNode["InstanceType"].asString();
+	if(!proxyMgrNode["Count"].isNull())
+		clusterInfo_.ecsInfo.proxyMgr.count = std::stoi(proxyMgrNode["Count"].asString());
 
 }
 

ehpc/src/model/DescribeContainerAppRequest.cc

@@ -0,0 +1,45 @@
+/*
+ * 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/ehpc/model/DescribeContainerAppRequest.h>
+
+using AlibabaCloud::EHPC::Model::DescribeContainerAppRequest;
+
+DescribeContainerAppRequest::DescribeContainerAppRequest()
+    : RpcServiceRequest("ehpc", "2018-04-12", "DescribeContainerApp") {
+  setMethod(HttpRequest::Method::Get);
+}
+
+DescribeContainerAppRequest::~DescribeContainerAppRequest() {}
+
+std::string DescribeContainerAppRequest::getAccessKeyId() const {
+  return accessKeyId_;
+}
+
+void DescribeContainerAppRequest::setAccessKeyId(const std::string &accessKeyId) {
+  accessKeyId_ = accessKeyId;
+  setParameter(std::string("AccessKeyId"), accessKeyId);
+}
+
+std::string DescribeContainerAppRequest::getContainerId() const {
+  return containerId_;
+}
+
+void DescribeContainerAppRequest::setContainerId(const std::string &containerId) {
+  containerId_ = containerId;
+  setParameter(std::string("ContainerId"), containerId);
+}
+

ehpc/src/model/DescribeContainerAppResult.cc

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

ehpc/src/model/DescribeEstackImageRequest.cc

@@ -0,0 +1,54 @@
+/*
+ * 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/ehpc/model/DescribeEstackImageRequest.h>
+
+using AlibabaCloud::EHPC::Model::DescribeEstackImageRequest;
+
+DescribeEstackImageRequest::DescribeEstackImageRequest()
+    : RpcServiceRequest("ehpc", "2018-04-12", "DescribeEstackImage") {
+  setMethod(HttpRequest::Method::Get);
+}
+
+DescribeEstackImageRequest::~DescribeEstackImageRequest() {}
+
+int DescribeEstackImageRequest::getPageNumber() const {
+  return pageNumber_;
+}
+
+void DescribeEstackImageRequest::setPageNumber(int pageNumber) {
+  pageNumber_ = pageNumber;
+  setParameter(std::string("PageNumber"), std::to_string(pageNumber));
+}
+
+std::string DescribeEstackImageRequest::getAccessKeyId() const {
+  return accessKeyId_;
+}
+
+void DescribeEstackImageRequest::setAccessKeyId(const std::string &accessKeyId) {
+  accessKeyId_ = accessKeyId;
+  setParameter(std::string("AccessKeyId"), accessKeyId);
+}
+
+int DescribeEstackImageRequest::getPageSize() const {
+  return pageSize_;
+}
+
+void DescribeEstackImageRequest::setPageSize(int pageSize) {
+  pageSize_ = pageSize;
+  setParameter(std::string("PageSize"), std::to_string(pageSize));
+}
+

ehpc/src/model/DescribeEstackImageResult.cc

@@ -0,0 +1,86 @@
+/*
+ * 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/ehpc/model/DescribeEstackImageResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::EHPC;
+using namespace AlibabaCloud::EHPC::Model;
+
+DescribeEstackImageResult::DescribeEstackImageResult() :
+	ServiceResult()
+{}
+
+DescribeEstackImageResult::DescribeEstackImageResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+DescribeEstackImageResult::~DescribeEstackImageResult()
+{}
+
+void DescribeEstackImageResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto allImageListNode = value["ImageList"]["ImageListInfo"];
+	for (auto valueImageListImageListInfo : allImageListNode)
+	{
+		ImageListInfo imageListObject;
+		if(!valueImageListImageListInfo["ImageName"].isNull())
+			imageListObject.imageName = valueImageListImageListInfo["ImageName"].asString();
+		if(!valueImageListImageListInfo["ImageSize"].isNull())
+			imageListObject.imageSize = std::stoi(valueImageListImageListInfo["ImageSize"].asString());
+		if(!valueImageListImageListInfo["RecentUpdateTime"].isNull())
+			imageListObject.recentUpdateTime = valueImageListImageListInfo["RecentUpdateTime"].asString();
+		if(!valueImageListImageListInfo["ImageUrl"].isNull())
+			imageListObject.imageUrl = valueImageListImageListInfo["ImageUrl"].asString();
+		if(!valueImageListImageListInfo["ImageType"].isNull())
+			imageListObject.imageType = valueImageListImageListInfo["ImageType"].asString();
+		imageList_.push_back(imageListObject);
+	}
+	if(!value["PageSize"].isNull())
+		pageSize_ = std::stoi(value["PageSize"].asString());
+	if(!value["PageNumber"].isNull())
+		pageNumber_ = std::stoi(value["PageNumber"].asString());
+	if(!value["TotalCount"].isNull())
+		totalCount_ = std::stoi(value["TotalCount"].asString());
+
+}
+
+int DescribeEstackImageResult::getTotalCount()const
+{
+	return totalCount_;
+}
+
+int DescribeEstackImageResult::getPageSize()const
+{
+	return pageSize_;
+}
+
+int DescribeEstackImageResult::getPageNumber()const
+{
+	return pageNumber_;
+}
+
+std::vector<DescribeEstackImageResult::ImageListInfo> DescribeEstackImageResult::getImageList()const
+{
+	return imageList_;
+}
+

ehpc/src/model/DescribeGWSClusterPolicyRequest.cc

@@ -0,0 +1,63 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/ehpc/model/DescribeGWSClusterPolicyRequest.h>
+
+using AlibabaCloud::EHPC::Model::DescribeGWSClusterPolicyRequest;
+
+DescribeGWSClusterPolicyRequest::DescribeGWSClusterPolicyRequest()
+    : RpcServiceRequest("ehpc", "2018-04-12", "DescribeGWSClusterPolicy") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+DescribeGWSClusterPolicyRequest::~DescribeGWSClusterPolicyRequest() {}
+
+std::string DescribeGWSClusterPolicyRequest::getClusterId() const {
+  return clusterId_;
+}
+
+void DescribeGWSClusterPolicyRequest::setClusterId(const std::string &clusterId) {
+  clusterId_ = clusterId;
+  setParameter(std::string("ClusterId"), clusterId);
+}
+
+std::string DescribeGWSClusterPolicyRequest::getAccessKeyId() const {
+  return accessKeyId_;
+}
+
+void DescribeGWSClusterPolicyRequest::setAccessKeyId(const std::string &accessKeyId) {
+  accessKeyId_ = accessKeyId;
+  setParameter(std::string("AccessKeyId"), accessKeyId);
+}
+
+bool DescribeGWSClusterPolicyRequest::getAsyncMode() const {
+  return asyncMode_;
+}
+
+void DescribeGWSClusterPolicyRequest::setAsyncMode(bool asyncMode) {
+  asyncMode_ = asyncMode;
+  setParameter(std::string("AsyncMode"), asyncMode ? "true" : "false");
+}
+
+std::string DescribeGWSClusterPolicyRequest::getTaskId() const {
+  return taskId_;
+}
+
+void DescribeGWSClusterPolicyRequest::setTaskId(const std::string &taskId) {
+  taskId_ = taskId;
+  setParameter(std::string("TaskId"), taskId);
+}
+

ehpc/src/model/DescribeGWSClusterPolicyResult.cc

@@ -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.
+ */
+
+#include <alibabacloud/ehpc/model/DescribeGWSClusterPolicyResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::EHPC;
+using namespace AlibabaCloud::EHPC::Model;
+
+DescribeGWSClusterPolicyResult::DescribeGWSClusterPolicyResult() :
+	ServiceResult()
+{}
+
+DescribeGWSClusterPolicyResult::DescribeGWSClusterPolicyResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+DescribeGWSClusterPolicyResult::~DescribeGWSClusterPolicyResult()
+{}
+
+void DescribeGWSClusterPolicyResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	if(!value["Watermark"].isNull())
+		watermark_ = value["Watermark"].asString();
+	if(!value["Clipboard"].isNull())
+		clipboard_ = value["Clipboard"].asString();
+	if(!value["UsbRedirect"].isNull())
+		usbRedirect_ = value["UsbRedirect"].asString();
+	if(!value["LocalDrive"].isNull())
+		localDrive_ = value["LocalDrive"].asString();
+
+}
+
+std::string DescribeGWSClusterPolicyResult::getLocalDrive()const
+{
+	return localDrive_;
+}
+
+std::string DescribeGWSClusterPolicyResult::getUsbRedirect()const
+{
+	return usbRedirect_;
+}
+
+std::string DescribeGWSClusterPolicyResult::getClipboard()const
+{
+	return clipboard_;
+}
+
+std::string DescribeGWSClusterPolicyResult::getWatermark()const
+{
+	return watermark_;
+}
+

ehpc/src/model/DescribeGWSClustersRequest.cc

@@ -0,0 +1,63 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/ehpc/model/DescribeGWSClustersRequest.h>
+
+using AlibabaCloud::EHPC::Model::DescribeGWSClustersRequest;
+
+DescribeGWSClustersRequest::DescribeGWSClustersRequest()
+    : RpcServiceRequest("ehpc", "2018-04-12", "DescribeGWSClusters") {
+  setMethod(HttpRequest::Method::Get);
+}
+
+DescribeGWSClustersRequest::~DescribeGWSClustersRequest() {}
+
+std::string DescribeGWSClustersRequest::getClusterId() const {
+  return clusterId_;
+}
+
+void DescribeGWSClustersRequest::setClusterId(const std::string &clusterId) {
+  clusterId_ = clusterId;
+  setParameter(std::string("ClusterId"), clusterId);
+}
+
+int DescribeGWSClustersRequest::getPageNumber() const {
+  return pageNumber_;
+}
+
+void DescribeGWSClustersRequest::setPageNumber(int pageNumber) {
+  pageNumber_ = pageNumber;
+  setParameter(std::string("PageNumber"), std::to_string(pageNumber));
+}
+
+std::string DescribeGWSClustersRequest::getAccessKeyId() const {
+  return accessKeyId_;
+}
+
+void DescribeGWSClustersRequest::setAccessKeyId(const std::string &accessKeyId) {
+  accessKeyId_ = accessKeyId;
+  setParameter(std::string("AccessKeyId"), accessKeyId);
+}
+
+int DescribeGWSClustersRequest::getPageSize() const {
+  return pageSize_;
+}
+
+void DescribeGWSClustersRequest::setPageSize(int pageSize) {
+  pageSize_ = pageSize;
+  setParameter(std::string("PageSize"), std::to_string(pageSize));
+}
+

ehpc/src/model/DescribeGWSClustersResult.cc

@@ -0,0 +1,93 @@
+/*
+ * 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/ehpc/model/DescribeGWSClustersResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::EHPC;
+using namespace AlibabaCloud::EHPC::Model;
+
+DescribeGWSClustersResult::DescribeGWSClustersResult() :
+	ServiceResult()
+{}
+
+DescribeGWSClustersResult::DescribeGWSClustersResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+DescribeGWSClustersResult::~DescribeGWSClustersResult()
+{}
+
+void DescribeGWSClustersResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto allClustersNode = value["Clusters"]["ClusterInfo"];
+	for (auto valueClustersClusterInfo : allClustersNode)
+	{
+		ClusterInfo clustersObject;
+		if(!valueClustersClusterInfo["VpcId"].isNull())
+			clustersObject.vpcId = valueClustersClusterInfo["VpcId"].asString();
+		if(!valueClustersClusterInfo["Status"].isNull())
+			clustersObject.status = valueClustersClusterInfo["Status"].asString();
+		if(!valueClustersClusterInfo["InstanceCount"].isNull())
+			clustersObject.instanceCount = std::stoi(valueClustersClusterInfo["InstanceCount"].asString());
+		if(!valueClustersClusterInfo["CreateTime"].isNull())
+			clustersObject.createTime = valueClustersClusterInfo["CreateTime"].asString();
+		if(!valueClustersClusterInfo["ClusterId"].isNull())
+			clustersObject.clusterId = valueClustersClusterInfo["ClusterId"].asString();
+		clusters_.push_back(clustersObject);
+	}
+	if(!value["PageSize"].isNull())
+		pageSize_ = std::stoi(value["PageSize"].asString());
+	if(!value["PageNumber"].isNull())
+		pageNumber_ = std::stoi(value["PageNumber"].asString());
+	if(!value["CallerType"].isNull())
+		callerType_ = value["CallerType"].asString();
+	if(!value["TotalCount"].isNull())
+		totalCount_ = std::stoi(value["TotalCount"].asString());
+
+}
+
+int DescribeGWSClustersResult::getTotalCount()const
+{
+	return totalCount_;
+}
+
+int DescribeGWSClustersResult::getPageSize()const
+{
+	return pageSize_;
+}
+
+int DescribeGWSClustersResult::getPageNumber()const
+{
+	return pageNumber_;
+}
+
+std::vector<DescribeGWSClustersResult::ClusterInfo> DescribeGWSClustersResult::getClusters()const
+{
+	return clusters_;
+}
+
+std::string DescribeGWSClustersResult::getCallerType()const
+{
+	return callerType_;
+}
+

ehpc/src/model/DescribeGWSImagesRequest.cc

@@ -0,0 +1,54 @@
+/*
+ * 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/ehpc/model/DescribeGWSImagesRequest.h>
+
+using AlibabaCloud::EHPC::Model::DescribeGWSImagesRequest;
+
+DescribeGWSImagesRequest::DescribeGWSImagesRequest()
+    : RpcServiceRequest("ehpc", "2018-04-12", "DescribeGWSImages") {
+  setMethod(HttpRequest::Method::Get);
+}
+
+DescribeGWSImagesRequest::~DescribeGWSImagesRequest() {}
+
+int DescribeGWSImagesRequest::getPageNumber() const {
+  return pageNumber_;
+}
+
+void DescribeGWSImagesRequest::setPageNumber(int pageNumber) {
+  pageNumber_ = pageNumber;
+  setParameter(std::string("PageNumber"), std::to_string(pageNumber));
+}
+
+std::string DescribeGWSImagesRequest::getAccessKeyId() const {
+  return accessKeyId_;
+}
+
+void DescribeGWSImagesRequest::setAccessKeyId(const std::string &accessKeyId) {
+  accessKeyId_ = accessKeyId;
+  setParameter(std::string("AccessKeyId"), accessKeyId);
+}
+
+int DescribeGWSImagesRequest::getPageSize() const {
+  return pageSize_;
+}
+
+void DescribeGWSImagesRequest::setPageSize(int pageSize) {
+  pageSize_ = pageSize;
+  setParameter(std::string("PageSize"), std::to_string(pageSize));
+}
+

ehpc/src/model/DescribeGWSImagesResult.cc

@@ -0,0 +1,90 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/ehpc/model/DescribeGWSImagesResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::EHPC;
+using namespace AlibabaCloud::EHPC::Model;
+
+DescribeGWSImagesResult::DescribeGWSImagesResult() :
+	ServiceResult()
+{}
+
+DescribeGWSImagesResult::DescribeGWSImagesResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+DescribeGWSImagesResult::~DescribeGWSImagesResult()
+{}
+
+void DescribeGWSImagesResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto allImagesNode = value["Images"]["ImageInfo"];
+	for (auto valueImagesImageInfo : allImagesNode)
+	{
+		ImageInfo imagesObject;
+		if(!valueImagesImageInfo["Status"].isNull())
+			imagesObject.status = valueImagesImageInfo["Status"].asString();
+		if(!valueImagesImageInfo["ImageType"].isNull())
+			imagesObject.imageType = valueImagesImageInfo["ImageType"].asString();
+		if(!valueImagesImageInfo["Progress"].isNull())
+			imagesObject.progress = valueImagesImageInfo["Progress"].asString();
+		if(!valueImagesImageInfo["Size"].isNull())
+			imagesObject.size = std::stoi(valueImagesImageInfo["Size"].asString());
+		if(!valueImagesImageInfo["CreateTime"].isNull())
+			imagesObject.createTime = valueImagesImageInfo["CreateTime"].asString();
+		if(!valueImagesImageInfo["Name"].isNull())
+			imagesObject.name = valueImagesImageInfo["Name"].asString();
+		if(!valueImagesImageInfo["ImageId"].isNull())
+			imagesObject.imageId = valueImagesImageInfo["ImageId"].asString();
+		images_.push_back(imagesObject);
+	}
+	if(!value["PageSize"].isNull())
+		pageSize_ = std::stoi(value["PageSize"].asString());
+	if(!value["PageNumber"].isNull())
+		pageNumber_ = std::stoi(value["PageNumber"].asString());
+	if(!value["TotalCount"].isNull())
+		totalCount_ = std::stoi(value["TotalCount"].asString());
+
+}
+
+int DescribeGWSImagesResult::getTotalCount()const
+{
+	return totalCount_;
+}
+
+int DescribeGWSImagesResult::getPageSize()const
+{
+	return pageSize_;
+}
+
+int DescribeGWSImagesResult::getPageNumber()const
+{
+	return pageNumber_;
+}
+
+std::vector<DescribeGWSImagesResult::ImageInfo> DescribeGWSImagesResult::getImages()const
+{
+	return images_;
+}
+

ehpc/src/model/DescribeGWSInstancesRequest.cc

@@ -0,0 +1,90 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/ehpc/model/DescribeGWSInstancesRequest.h>
+
+using AlibabaCloud::EHPC::Model::DescribeGWSInstancesRequest;
+
+DescribeGWSInstancesRequest::DescribeGWSInstancesRequest()
+    : RpcServiceRequest("ehpc", "2018-04-12", "DescribeGWSInstances") {
+  setMethod(HttpRequest::Method::Get);
+}
+
+DescribeGWSInstancesRequest::~DescribeGWSInstancesRequest() {}
+
+std::string DescribeGWSInstancesRequest::getClusterId() const {
+  return clusterId_;
+}
+
+void DescribeGWSInstancesRequest::setClusterId(const std::string &clusterId) {
+  clusterId_ = clusterId;
+  setParameter(std::string("ClusterId"), clusterId);
+}
+
+int DescribeGWSInstancesRequest::getPageNumber() const {
+  return pageNumber_;
+}
+
+void DescribeGWSInstancesRequest::setPageNumber(int pageNumber) {
+  pageNumber_ = pageNumber;
+  setParameter(std::string("PageNumber"), std::to_string(pageNumber));
+}
+
+std::string DescribeGWSInstancesRequest::getAccessKeyId() const {
+  return accessKeyId_;
+}
+
+void DescribeGWSInstancesRequest::setAccessKeyId(const std::string &accessKeyId) {
+  accessKeyId_ = accessKeyId;
+  setParameter(std::string("AccessKeyId"), accessKeyId);
+}
+
+std::string DescribeGWSInstancesRequest::getInstanceId() const {
+  return instanceId_;
+}
+
+void DescribeGWSInstancesRequest::setInstanceId(const std::string &instanceId) {
+  instanceId_ = instanceId;
+  setParameter(std::string("InstanceId"), instanceId);
+}
+
+int DescribeGWSInstancesRequest::getPageSize() const {
+  return pageSize_;
+}
+
+void DescribeGWSInstancesRequest::setPageSize(int pageSize) {
+  pageSize_ = pageSize;
+  setParameter(std::string("PageSize"), std::to_string(pageSize));
+}
+
+long DescribeGWSInstancesRequest::getUserUid() const {
+  return userUid_;
+}
+
+void DescribeGWSInstancesRequest::setUserUid(long userUid) {
+  userUid_ = userUid;
+  setParameter(std::string("UserUid"), std::to_string(userUid));
+}
+
+std::string DescribeGWSInstancesRequest::getUserName() const {
+  return userName_;
+}
+
+void DescribeGWSInstancesRequest::setUserName(const std::string &userName) {
+  userName_ = userName;
+  setParameter(std::string("UserName"), userName);
+}
+

ehpc/src/model/DescribeGWSInstancesResult.cc

@@ -0,0 +1,106 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/ehpc/model/DescribeGWSInstancesResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::EHPC;
+using namespace AlibabaCloud::EHPC::Model;
+
+DescribeGWSInstancesResult::DescribeGWSInstancesResult() :
+	ServiceResult()
+{}
+
+DescribeGWSInstancesResult::DescribeGWSInstancesResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+DescribeGWSInstancesResult::~DescribeGWSInstancesResult()
+{}
+
+void DescribeGWSInstancesResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto allInstancesNode = value["Instances"]["InstanceInfo"];
+	for (auto valueInstancesInstanceInfo : allInstancesNode)
+	{
+		InstanceInfo instancesObject;
+		if(!valueInstancesInstanceInfo["Status"].isNull())
+			instancesObject.status = valueInstancesInstanceInfo["Status"].asString();
+		if(!valueInstancesInstanceInfo["WorkMode"].isNull())
+			instancesObject.workMode = valueInstancesInstanceInfo["WorkMode"].asString();
+		if(!valueInstancesInstanceInfo["ExpireTime"].isNull())
+			instancesObject.expireTime = valueInstancesInstanceInfo["ExpireTime"].asString();
+		if(!valueInstancesInstanceInfo["CreateTime"].isNull())
+			instancesObject.createTime = valueInstancesInstanceInfo["CreateTime"].asString();
+		if(!valueInstancesInstanceInfo["InstanceId"].isNull())
+			instancesObject.instanceId = valueInstancesInstanceInfo["InstanceId"].asString();
+		if(!valueInstancesInstanceInfo["Name"].isNull())
+			instancesObject.name = valueInstancesInstanceInfo["Name"].asString();
+		if(!valueInstancesInstanceInfo["InstanceType"].isNull())
+			instancesObject.instanceType = valueInstancesInstanceInfo["InstanceType"].asString();
+		if(!valueInstancesInstanceInfo["UserName"].isNull())
+			instancesObject.userName = valueInstancesInstanceInfo["UserName"].asString();
+		if(!valueInstancesInstanceInfo["ClusterId"].isNull())
+			instancesObject.clusterId = valueInstancesInstanceInfo["ClusterId"].asString();
+		auto allAppListNode = valueInstancesInstanceInfo["AppList"]["AppInfo"];
+		for (auto valueInstancesInstanceInfoAppListAppInfo : allAppListNode)
+		{
+			InstanceInfo::AppInfo appListObject;
+			if(!valueInstancesInstanceInfoAppListAppInfo["AppName"].isNull())
+				appListObject.appName = valueInstancesInstanceInfoAppListAppInfo["AppName"].asString();
+			if(!valueInstancesInstanceInfoAppListAppInfo["AppArgs"].isNull())
+				appListObject.appArgs = valueInstancesInstanceInfoAppListAppInfo["AppArgs"].asString();
+			if(!valueInstancesInstanceInfoAppListAppInfo["AppPath"].isNull())
+				appListObject.appPath = valueInstancesInstanceInfoAppListAppInfo["AppPath"].asString();
+			instancesObject.appList.push_back(appListObject);
+		}
+		instances_.push_back(instancesObject);
+	}
+	if(!value["PageSize"].isNull())
+		pageSize_ = std::stoi(value["PageSize"].asString());
+	if(!value["PageNumber"].isNull())
+		pageNumber_ = std::stoi(value["PageNumber"].asString());
+	if(!value["TotalCount"].isNull())
+		totalCount_ = std::stoi(value["TotalCount"].asString());
+
+}
+
+std::vector<DescribeGWSInstancesResult::InstanceInfo> DescribeGWSInstancesResult::getInstances()const
+{
+	return instances_;
+}
+
+int DescribeGWSInstancesResult::getTotalCount()const
+{
+	return totalCount_;
+}
+
+int DescribeGWSInstancesResult::getPageSize()const
+{
+	return pageSize_;
+}
+
+int DescribeGWSInstancesResult::getPageNumber()const
+{
+	return pageNumber_;
+}
+

ehpc/src/model/DescribeImageGatewayConfigRequest.cc

@@ -0,0 +1,45 @@
+/*
+ * 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/ehpc/model/DescribeImageGatewayConfigRequest.h>
+
+using AlibabaCloud::EHPC::Model::DescribeImageGatewayConfigRequest;
+
+DescribeImageGatewayConfigRequest::DescribeImageGatewayConfigRequest()
+    : RpcServiceRequest("ehpc", "2018-04-12", "DescribeImageGatewayConfig") {
+  setMethod(HttpRequest::Method::Get);
+}
+
+DescribeImageGatewayConfigRequest::~DescribeImageGatewayConfigRequest() {}
+
+std::string DescribeImageGatewayConfigRequest::getClusterId() const {
+  return clusterId_;
+}
+
+void DescribeImageGatewayConfigRequest::setClusterId(const std::string &clusterId) {
+  clusterId_ = clusterId;
+  setParameter(std::string("ClusterId"), clusterId);
+}
+
+std::string DescribeImageGatewayConfigRequest::getAccessKeyId() const {
+  return accessKeyId_;
+}
+
+void DescribeImageGatewayConfigRequest::setAccessKeyId(const std::string &accessKeyId) {
+  accessKeyId_ = accessKeyId;
+  setParameter(std::string("AccessKeyId"), accessKeyId);
+}
+

ehpc/src/model/DescribeImageGatewayConfigResult.cc

@@ -0,0 +1,74 @@
+/*
+ * 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/ehpc/model/DescribeImageGatewayConfigResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::EHPC;
+using namespace AlibabaCloud::EHPC::Model;
+
+DescribeImageGatewayConfigResult::DescribeImageGatewayConfigResult() :
+	ServiceResult()
+{}
+
+DescribeImageGatewayConfigResult::DescribeImageGatewayConfigResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+DescribeImageGatewayConfigResult::~DescribeImageGatewayConfigResult()
+{}
+
+void DescribeImageGatewayConfigResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto imagegwNode = value["Imagegw"];
+	if(!imagegwNode["UpdateDateTime"].isNull())
+		imagegw_.updateDateTime = imagegwNode["UpdateDateTime"].asString();
+	if(!imagegwNode["ImageExpirationTimeout"].isNull())
+		imagegw_.imageExpirationTimeout = imagegwNode["ImageExpirationTimeout"].asString();
+	if(!imagegwNode["MongoDBURI"].isNull())
+		imagegw_.mongoDBURI = imagegwNode["MongoDBURI"].asString();
+	if(!imagegwNode["DefaultImageLocation"].isNull())
+		imagegw_.defaultImageLocation = imagegwNode["DefaultImageLocation"].asString();
+	if(!imagegwNode["PullUpdateTimeout"].isNull())
+		imagegw_.pullUpdateTimeout = std::stol(imagegwNode["PullUpdateTimeout"].asString());
+	auto allLocationsNode = imagegwNode["Locations"]["LocationInfo"];
+	for (auto imagegwNodeLocationsLocationInfo : allLocationsNode)
+	{
+		Imagegw::LocationInfo locationInfoObject;
+		if(!imagegwNodeLocationsLocationInfo["URL"].isNull())
+			locationInfoObject.uRL = imagegwNodeLocationsLocationInfo["URL"].asString();
+		if(!imagegwNodeLocationsLocationInfo["RemoteType"].isNull())
+			locationInfoObject.remoteType = imagegwNodeLocationsLocationInfo["RemoteType"].asString();
+		if(!imagegwNodeLocationsLocationInfo["Location"].isNull())
+			locationInfoObject.location = imagegwNodeLocationsLocationInfo["Location"].asString();
+		if(!imagegwNodeLocationsLocationInfo["Authentication"].isNull())
+			locationInfoObject.authentication = imagegwNodeLocationsLocationInfo["Authentication"].asString();
+		imagegw_.locations.push_back(locationInfoObject);
+	}
+
+}
+
+DescribeImageGatewayConfigResult::Imagegw DescribeImageGatewayConfigResult::getImagegw()const
+{
+	return imagegw_;
+}
+

ehpc/src/model/DescribeImagePriceRequest.cc

@@ -0,0 +1,90 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/ehpc/model/DescribeImagePriceRequest.h>
+
+using AlibabaCloud::EHPC::Model::DescribeImagePriceRequest;
+
+DescribeImagePriceRequest::DescribeImagePriceRequest()
+    : RpcServiceRequest("ehpc", "2018-04-12", "DescribeImagePrice") {
+  setMethod(HttpRequest::Method::Get);
+}
+
+DescribeImagePriceRequest::~DescribeImagePriceRequest() {}
+
+int DescribeImagePriceRequest::getPeriod() const {
+  return period_;
+}
+
+void DescribeImagePriceRequest::setPeriod(int period) {
+  period_ = period;
+  setParameter(std::string("Period"), std::to_string(period));
+}
+
+int DescribeImagePriceRequest::getAmount() const {
+  return amount_;
+}
+
+void DescribeImagePriceRequest::setAmount(int amount) {
+  amount_ = amount;
+  setParameter(std::string("Amount"), std::to_string(amount));
+}
+
+std::string DescribeImagePriceRequest::getImageId() const {
+  return imageId_;
+}
+
+void DescribeImagePriceRequest::setImageId(const std::string &imageId) {
+  imageId_ = imageId;
+  setParameter(std::string("ImageId"), imageId);
+}
+
+std::string DescribeImagePriceRequest::getSkuCode() const {
+  return skuCode_;
+}
+
+void DescribeImagePriceRequest::setSkuCode(const std::string &skuCode) {
+  skuCode_ = skuCode;
+  setParameter(std::string("SkuCode"), skuCode);
+}
+
+std::string DescribeImagePriceRequest::getAccessKeyId() const {
+  return accessKeyId_;
+}
+
+void DescribeImagePriceRequest::setAccessKeyId(const std::string &accessKeyId) {
+  accessKeyId_ = accessKeyId;
+  setParameter(std::string("AccessKeyId"), accessKeyId);
+}
+
+std::string DescribeImagePriceRequest::getPriceUnit() const {
+  return priceUnit_;
+}
+
+void DescribeImagePriceRequest::setPriceUnit(const std::string &priceUnit) {
+  priceUnit_ = priceUnit;
+  setParameter(std::string("PriceUnit"), priceUnit);
+}
+
+std::string DescribeImagePriceRequest::getOrderType() const {
+  return orderType_;
+}
+
+void DescribeImagePriceRequest::setOrderType(const std::string &orderType) {
+  orderType_ = orderType;
+  setParameter(std::string("OrderType"), orderType);
+}
+

ehpc/src/model/DescribeImagePriceResult.cc

@@ -0,0 +1,79 @@
+/*
+ * 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/ehpc/model/DescribeImagePriceResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::EHPC;
+using namespace AlibabaCloud::EHPC::Model;
+
+DescribeImagePriceResult::DescribeImagePriceResult() :
+	ServiceResult()
+{}
+
+DescribeImagePriceResult::DescribeImagePriceResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+DescribeImagePriceResult::~DescribeImagePriceResult()
+{}
+
+void DescribeImagePriceResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	if(!value["Amount"].isNull())
+		amount_ = std::stoi(value["Amount"].asString());
+	if(!value["DiscountPrice"].isNull())
+		discountPrice_ = std::stof(value["DiscountPrice"].asString());
+	if(!value["TradePrice"].isNull())
+		tradePrice_ = std::stof(value["TradePrice"].asString());
+	if(!value["OriginalPrice"].isNull())
+		originalPrice_ = std::stof(value["OriginalPrice"].asString());
+	if(!value["ImageId"].isNull())
+		imageId_ = value["ImageId"].asString();
+
+}
+
+float DescribeImagePriceResult::getOriginalPrice()const
+{
+	return originalPrice_;
+}
+
+int DescribeImagePriceResult::getAmount()const
+{
+	return amount_;
+}
+
+float DescribeImagePriceResult::getDiscountPrice()const
+{
+	return discountPrice_;
+}
+
+std::string DescribeImagePriceResult::getImageId()const
+{
+	return imageId_;
+}
+
+float DescribeImagePriceResult::getTradePrice()const
+{
+	return tradePrice_;
+}
+

ehpc/src/model/DescribeImageRequest.cc

@@ -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.
+ */
+
+#include <alibabacloud/ehpc/model/DescribeImageRequest.h>
+
+using AlibabaCloud::EHPC::Model::DescribeImageRequest;
+
+DescribeImageRequest::DescribeImageRequest()
+    : RpcServiceRequest("ehpc", "2018-04-12", "DescribeImage") {
+  setMethod(HttpRequest::Method::Get);
+}
+
+DescribeImageRequest::~DescribeImageRequest() {}
+
+std::string DescribeImageRequest::getClusterId() const {
+  return clusterId_;
+}
+
+void DescribeImageRequest::setClusterId(const std::string &clusterId) {
+  clusterId_ = clusterId;
+  setParameter(std::string("ClusterId"), clusterId);
+}
+
+std::string DescribeImageRequest::getRepository() const {
+  return repository_;
+}
+
+void DescribeImageRequest::setRepository(const std::string &repository) {
+  repository_ = repository;
+  setParameter(std::string("Repository"), repository);
+}
+
+std::string DescribeImageRequest::getAccessKeyId() const {
+  return accessKeyId_;
+}
+
+void DescribeImageRequest::setAccessKeyId(const std::string &accessKeyId) {
+  accessKeyId_ = accessKeyId;
+  setParameter(std::string("AccessKeyId"), accessKeyId);
+}
+
+std::string DescribeImageRequest::getContainerType() const {
+  return containerType_;
+}
+
+void DescribeImageRequest::setContainerType(const std::string &containerType) {
+  containerType_ = containerType;
+  setParameter(std::string("ContainerType"), containerType);
+}
+
+std::string DescribeImageRequest::getImageTag() const {
+  return imageTag_;
+}
+
+void DescribeImageRequest::setImageTag(const std::string &imageTag) {
+  imageTag_ = imageTag;
+  setParameter(std::string("ImageTag"), imageTag);
+}
+

ehpc/src/model/DescribeImageResult.cc

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

ehpc/src/model/DescribeJobRequest.cc

@@ -0,0 +1,54 @@
+/*
+ * 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/ehpc/model/DescribeJobRequest.h>
+
+using AlibabaCloud::EHPC::Model::DescribeJobRequest;
+
+DescribeJobRequest::DescribeJobRequest()
+    : RpcServiceRequest("ehpc", "2018-04-12", "DescribeJob") {
+  setMethod(HttpRequest::Method::Get);
+}
+
+DescribeJobRequest::~DescribeJobRequest() {}
+
+std::string DescribeJobRequest::getClusterId() const {
+  return clusterId_;
+}
+
+void DescribeJobRequest::setClusterId(const std::string &clusterId) {
+  clusterId_ = clusterId;
+  setParameter(std::string("ClusterId"), clusterId);
+}
+
+std::string DescribeJobRequest::getAccessKeyId() const {
+  return accessKeyId_;
+}
+
+void DescribeJobRequest::setAccessKeyId(const std::string &accessKeyId) {
+  accessKeyId_ = accessKeyId;
+  setParameter(std::string("AccessKeyId"), accessKeyId);
+}
+
+std::string DescribeJobRequest::getJobId() const {
+  return jobId_;
+}
+
+void DescribeJobRequest::setJobId(const std::string &jobId) {
+  jobId_ = jobId;
+  setParameter(std::string("JobId"), jobId);
+}
+

ehpc/src/model/DescribeJobResult.cc

@@ -0,0 +1,52 @@
+/*
+ * 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/ehpc/model/DescribeJobResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::EHPC;
+using namespace AlibabaCloud::EHPC::Model;
+
+DescribeJobResult::DescribeJobResult() :
+	ServiceResult()
+{}
+
+DescribeJobResult::DescribeJobResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+DescribeJobResult::~DescribeJobResult()
+{}
+
+void DescribeJobResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto messageNode = value["Message"];
+	if(!messageNode["JobInfo"].isNull())
+		message_.jobInfo = messageNode["JobInfo"].asString();
+
+}
+
+DescribeJobResult::Message DescribeJobResult::getMessage()const
+{
+	return message_;
+}
+

ehpc/src/model/DescribeNFSClientStatusRequest.cc

@@ -0,0 +1,45 @@
+/*
+ * 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/ehpc/model/DescribeNFSClientStatusRequest.h>
+
+using AlibabaCloud::EHPC::Model::DescribeNFSClientStatusRequest;
+
+DescribeNFSClientStatusRequest::DescribeNFSClientStatusRequest()
+    : RpcServiceRequest("ehpc", "2018-04-12", "DescribeNFSClientStatus") {
+  setMethod(HttpRequest::Method::Get);
+}
+
+DescribeNFSClientStatusRequest::~DescribeNFSClientStatusRequest() {}
+
+std::string DescribeNFSClientStatusRequest::getAccessKeyId() const {
+  return accessKeyId_;
+}
+
+void DescribeNFSClientStatusRequest::setAccessKeyId(const std::string &accessKeyId) {
+  accessKeyId_ = accessKeyId;
+  setParameter(std::string("AccessKeyId"), accessKeyId);
+}
+
+std::string DescribeNFSClientStatusRequest::getInstanceId() const {
+  return instanceId_;
+}
+
+void DescribeNFSClientStatusRequest::setInstanceId(const std::string &instanceId) {
+  instanceId_ = instanceId;
+  setParameter(std::string("InstanceId"), instanceId);
+}
+

ehpc/src/model/DescribeNFSClientStatusResult.cc

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

ehpc/src/model/DescribePriceRequest.cc

@@ -0,0 +1,94 @@
+/*
+ * 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/ehpc/model/DescribePriceRequest.h>
+
+using AlibabaCloud::EHPC::Model::DescribePriceRequest;
+
+DescribePriceRequest::DescribePriceRequest()
+    : RpcServiceRequest("ehpc", "2018-04-12", "DescribePrice") {
+  setMethod(HttpRequest::Method::Get);
+}
+
+DescribePriceRequest::~DescribePriceRequest() {}
+
+std::vector<DescribePriceRequest::Commodities> DescribePriceRequest::getCommodities() const {
+  return commodities_;
+}
+
+void DescribePriceRequest::setCommodities(const std::vector<DescribePriceRequest::Commodities> &commodities) {
+  commodities_ = commodities;
+  for(int dep1 = 0; dep1 != commodities.size(); dep1++) {
+  auto commoditiesObj = commodities.at(dep1);
+  std::string commoditiesObjStr = std::string("Commodities") + "." + std::to_string(dep1 + 1);
+    setParameter(commoditiesObjStr + ".Amount", std::to_string(commoditiesObj.amount));
+    setParameter(commoditiesObjStr + ".Period", std::to_string(commoditiesObj.period));
+    setParameter(commoditiesObjStr + ".NodeType", commoditiesObj.nodeType);
+    for(int dep2 = 0; dep2 != commoditiesObj.dataDisks.size(); dep2++) {
+    auto dataDisksObj = commoditiesObj.dataDisks.at(dep2);
+    std::string dataDisksObjStr = commoditiesObjStr + ".DataDisks" + "." + std::to_string(dep2 + 1);
+      setParameter(dataDisksObjStr + ".size", std::to_string(dataDisksObj.size));
+      setParameter(dataDisksObjStr + ".encrypted", dataDisksObj.encrypted ? "true" : "false");
+      setParameter(dataDisksObjStr + ".performanceLevel", dataDisksObj.performanceLevel);
+      setParameter(dataDisksObjStr + ".category", dataDisksObj.category);
+      setParameter(dataDisksObjStr + ".deleteWithInstance", dataDisksObj.deleteWithInstance ? "true" : "false");
+    }
+    setParameter(commoditiesObjStr + ".SystemDiskCategory", commoditiesObj.systemDiskCategory);
+    setParameter(commoditiesObjStr + ".InternetChargeType", commoditiesObj.internetChargeType);
+    setParameter(commoditiesObjStr + ".SystemDiskPerformanceLevel", commoditiesObj.systemDiskPerformanceLevel);
+    setParameter(commoditiesObjStr + ".SystemDiskSize", std::to_string(commoditiesObj.systemDiskSize));
+    setParameter(commoditiesObjStr + ".InternetMaxBandWidthOut", std::to_string(commoditiesObj.internetMaxBandWidthOut));
+    setParameter(commoditiesObjStr + ".InstanceType", commoditiesObj.instanceType);
+    setParameter(commoditiesObjStr + ".NetworkType", commoditiesObj.networkType);
+  }
+}
+
+std::string DescribePriceRequest::getAccessKeyId() const {
+  return accessKeyId_;
+}
+
+void DescribePriceRequest::setAccessKeyId(const std::string &accessKeyId) {
+  accessKeyId_ = accessKeyId;
+  setParameter(std::string("AccessKeyId"), accessKeyId);
+}
+
+std::string DescribePriceRequest::getPriceUnit() const {
+  return priceUnit_;
+}
+
+void DescribePriceRequest::setPriceUnit(const std::string &priceUnit) {
+  priceUnit_ = priceUnit;
+  setParameter(std::string("PriceUnit"), priceUnit);
+}
+
+std::string DescribePriceRequest::getChargeType() const {
+  return chargeType_;
+}
+
+void DescribePriceRequest::setChargeType(const std::string &chargeType) {
+  chargeType_ = chargeType;
+  setParameter(std::string("ChargeType"), chargeType);
+}
+
+std::string DescribePriceRequest::getOrderType() const {
+  return orderType_;
+}
+
+void DescribePriceRequest::setOrderType(const std::string &orderType) {
+  orderType_ = orderType;
+  setParameter(std::string("OrderType"), orderType);
+}
+

ehpc/src/model/DescribePriceResult.cc

@@ -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/ehpc/model/DescribePriceResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::EHPC;
+using namespace AlibabaCloud::EHPC::Model;
+
+DescribePriceResult::DescribePriceResult() :
+	ServiceResult()
+{}
+
+DescribePriceResult::DescribePriceResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+DescribePriceResult::~DescribePriceResult()
+{}
+
+void DescribePriceResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto allPricesNode = value["Prices"]["PriceInfo"];
+	for (auto valuePricesPriceInfo : allPricesNode)
+	{
+		PriceInfo pricesObject;
+		if(!valuePricesPriceInfo["OriginalPrice"].isNull())
+			pricesObject.originalPrice = std::stof(valuePricesPriceInfo["OriginalPrice"].asString());
+		if(!valuePricesPriceInfo["NodeType"].isNull())
+			pricesObject.nodeType = valuePricesPriceInfo["NodeType"].asString();
+		if(!valuePricesPriceInfo["Currency"].isNull())
+			pricesObject.currency = valuePricesPriceInfo["Currency"].asString();
+		if(!valuePricesPriceInfo["TradePrice"].isNull())
+			pricesObject.tradePrice = std::stof(valuePricesPriceInfo["TradePrice"].asString());
+		prices_.push_back(pricesObject);
+	}
+	if(!value["TotalTradePrice"].isNull())
+		totalTradePrice_ = std::stof(value["TotalTradePrice"].asString());
+
+}
+
+std::vector<DescribePriceResult::PriceInfo> DescribePriceResult::getPrices()const
+{
+	return prices_;
+}
+
+float DescribePriceResult::getTotalTradePrice()const
+{
+	return totalTradePrice_;
+}
+

ehpc/src/model/EditJobTemplateRequest.cc

@@ -19,7 +19,7 @@
 using AlibabaCloud::EHPC::Model::EditJobTemplateRequest;
 
 EditJobTemplateRequest::EditJobTemplateRequest()
-    : RpcServiceRequest("ehpc", "2017-07-14", "EditJobTemplate") {
+    : RpcServiceRequest("ehpc", "2018-04-12", "EditJobTemplate") {
   setMethod(HttpRequest::Method::Get);
 }
 
@@ -34,6 +34,15 @@ void EditJobTemplateRequest::setStderrRedirectPath(const std::string &stderrRedi
   setParameter(std::string("StderrRedirectPath"), stderrRedirectPath);
 }
 
+std::string EditJobTemplateRequest::getClockTime() const {
+  return clockTime_;
+}
+
+void EditJobTemplateRequest::setClockTime(const std::string &clockTime) {
+  clockTime_ = clockTime;
+  setParameter(std::string("ClockTime"), clockTime);
+}
+
 std::string EditJobTemplateRequest::getCommandLine() const {
   return commandLine_;
 }
@@ -61,6 +70,15 @@ void EditJobTemplateRequest::setArrayRequest(const std::string &arrayRequest) {
   setParameter(std::string("ArrayRequest"), arrayRequest);
 }
 
+std::string EditJobTemplateRequest::getUnzipCmd() const {
+  return unzipCmd_;
+}
+
+void EditJobTemplateRequest::setUnzipCmd(const std::string &unzipCmd) {
+  unzipCmd_ = unzipCmd;
+  setParameter(std::string("UnzipCmd"), unzipCmd);
+}
+
 std::string EditJobTemplateRequest::getPackagePath() const {
   return packagePath_;
 }
@@ -70,13 +88,13 @@ void EditJobTemplateRequest::setPackagePath(const std::string &packagePath) {
   setParameter(std::string("PackagePath"), packagePath);
 }
 
-std::string EditJobTemplateRequest::getRegionId() const {
-  return regionId_;
+std::string EditJobTemplateRequest::getMem() const {
+  return mem_;
 }
 
-void EditJobTemplateRequest::setRegionId(const std::string &regionId) {
-  regionId_ = regionId;
-  setParameter(std::string("RegionId"), regionId);
+void EditJobTemplateRequest::setMem(const std::string &mem) {
+  mem_ = mem;
+  setParameter(std::string("Mem"), mem);
 }
 
 std::string EditJobTemplateRequest::getStdoutRedirectPath() const {
@@ -115,6 +133,15 @@ void EditJobTemplateRequest::setReRunable(bool reRunable) {
   setParameter(std::string("ReRunable"), reRunable ? "true" : "false");
 }
 
+int EditJobTemplateRequest::getThread() const {
+  return thread_;
+}
+
+void EditJobTemplateRequest::setThread(int thread) {
+  thread_ = thread;
+  setParameter(std::string("Thread"), std::to_string(thread));
+}
+
 std::string EditJobTemplateRequest::getTemplateId() const {
   return templateId_;
 }
@@ -133,6 +160,51 @@ void EditJobTemplateRequest::setPriority(int priority) {
   setParameter(std::string("Priority"), std::to_string(priority));
 }
 
+int EditJobTemplateRequest::getGpu() const {
+  return gpu_;
+}
+
+void EditJobTemplateRequest::setGpu(int gpu) {
+  gpu_ = gpu;
+  setParameter(std::string("Gpu"), std::to_string(gpu));
+}
+
+bool EditJobTemplateRequest::getWithUnzipCmd() const {
+  return withUnzipCmd_;
+}
+
+void EditJobTemplateRequest::setWithUnzipCmd(bool withUnzipCmd) {
+  withUnzipCmd_ = withUnzipCmd;
+  setParameter(std::string("WithUnzipCmd"), withUnzipCmd ? "true" : "false");
+}
+
+int EditJobTemplateRequest::getNode() const {
+  return node_;
+}
+
+void EditJobTemplateRequest::setNode(int node) {
+  node_ = node;
+  setParameter(std::string("Node"), std::to_string(node));
+}
+
+int EditJobTemplateRequest::getTask() const {
+  return task_;
+}
+
+void EditJobTemplateRequest::setTask(int task) {
+  task_ = task;
+  setParameter(std::string("Task"), std::to_string(task));
+}
+
+std::string EditJobTemplateRequest::getInputFileUrl() const {
+  return inputFileUrl_;
+}
+
+void EditJobTemplateRequest::setInputFileUrl(const std::string &inputFileUrl) {
+  inputFileUrl_ = inputFileUrl;
+  setParameter(std::string("InputFileUrl"), inputFileUrl);
+}
+
 std::string EditJobTemplateRequest::getName() const {
   return name_;
 }
@@ -142,3 +214,12 @@ void EditJobTemplateRequest::setName(const std::string &name) {
   setParameter(std::string("Name"), name);
 }
 
+std::string EditJobTemplateRequest::getQueue() const {
+  return queue_;
+}
+
+void EditJobTemplateRequest::setQueue(const std::string &queue) {
+  queue_ = queue;
+  setParameter(std::string("Queue"), queue);
+}
+

ehpc/src/model/GetAccountingReportRequest.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/ehpc/model/GetAccountingReportRequest.h>
+
+using AlibabaCloud::EHPC::Model::GetAccountingReportRequest;
+
+GetAccountingReportRequest::GetAccountingReportRequest()
+    : RpcServiceRequest("ehpc", "2018-04-12", "GetAccountingReport") {
+  setMethod(HttpRequest::Method::Get);
+}
+
+GetAccountingReportRequest::~GetAccountingReportRequest() {}
+
+std::string GetAccountingReportRequest::getReportType() const {
+  return reportType_;
+}
+
+void GetAccountingReportRequest::setReportType(const std::string &reportType) {
+  reportType_ = reportType;
+  setParameter(std::string("ReportType"), reportType);
+}
+
+int GetAccountingReportRequest::getEndTime() const {
+  return endTime_;
+}
+
+void GetAccountingReportRequest::setEndTime(int endTime) {
+  endTime_ = endTime;
+  setParameter(std::string("EndTime"), std::to_string(endTime));
+}
+
+std::string GetAccountingReportRequest::getFilterValue() const {
+  return filterValue_;
+}
+
+void GetAccountingReportRequest::setFilterValue(const std::string &filterValue) {
+  filterValue_ = filterValue;
+  setParameter(std::string("FilterValue"), filterValue);
+}
+
+std::string GetAccountingReportRequest::getDim() const {
+  return dim_;
+}
+
+void GetAccountingReportRequest::setDim(const std::string &dim) {
+  dim_ = dim;
+  setParameter(std::string("Dim"), dim);
+}
+
+std::string GetAccountingReportRequest::getClusterId() const {
+  return clusterId_;
+}
+
+void GetAccountingReportRequest::setClusterId(const std::string &clusterId) {
+  clusterId_ = clusterId;
+  setParameter(std::string("ClusterId"), clusterId);
+}
+
+int GetAccountingReportRequest::getStartTime() const {
+  return startTime_;
+}
+
+void GetAccountingReportRequest::setStartTime(int startTime) {
+  startTime_ = startTime;
+  setParameter(std::string("StartTime"), std::to_string(startTime));
+}
+
+int GetAccountingReportRequest::getPageNumber() const {
+  return pageNumber_;
+}
+
+void GetAccountingReportRequest::setPageNumber(int pageNumber) {
+  pageNumber_ = pageNumber;
+  setParameter(std::string("PageNumber"), std::to_string(pageNumber));
+}
+
+std::string GetAccountingReportRequest::getAccessKeyId() const {
+  return accessKeyId_;
+}
+
+void GetAccountingReportRequest::setAccessKeyId(const std::string &accessKeyId) {
+  accessKeyId_ = accessKeyId;
+  setParameter(std::string("AccessKeyId"), accessKeyId);
+}
+
+std::string GetAccountingReportRequest::getJobId() const {
+  return jobId_;
+}
+
+void GetAccountingReportRequest::setJobId(const std::string &jobId) {
+  jobId_ = jobId;
+  setParameter(std::string("JobId"), jobId);
+}
+
+int GetAccountingReportRequest::getPageSize() const {
+  return pageSize_;
+}
+
+void GetAccountingReportRequest::setPageSize(int pageSize) {
+  pageSize_ = pageSize;
+  setParameter(std::string("PageSize"), std::to_string(pageSize));
+}
+

ehpc/src/model/GetAccountingReportResult.cc

@@ -0,0 +1,87 @@
+/*
+ * 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/ehpc/model/GetAccountingReportResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::EHPC;
+using namespace AlibabaCloud::EHPC::Model;
+
+GetAccountingReportResult::GetAccountingReportResult() :
+	ServiceResult()
+{}
+
+GetAccountingReportResult::GetAccountingReportResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+GetAccountingReportResult::~GetAccountingReportResult()
+{}
+
+void GetAccountingReportResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto allData = value["Data"]["Data"];
+	for (const auto &item : allData)
+		data_.push_back(item.asString());
+	if(!value["TotalCoreTime"].isNull())
+		totalCoreTime_ = std::stoi(value["TotalCoreTime"].asString());
+	if(!value["Metrics"].isNull())
+		metrics_ = value["Metrics"].asString();
+	if(!value["PageSize"].isNull())
+		pageSize_ = std::stoi(value["PageSize"].asString());
+	if(!value["PageNumber"].isNull())
+		pageNumber_ = std::stoi(value["PageNumber"].asString());
+	if(!value["TotalCount"].isNull())
+		totalCount_ = std::stoi(value["TotalCount"].asString());
+
+}
+
+std::string GetAccountingReportResult::getMetrics()const
+{
+	return metrics_;
+}
+
+int GetAccountingReportResult::getTotalCount()const
+{
+	return totalCount_;
+}
+
+int GetAccountingReportResult::getPageSize()const
+{
+	return pageSize_;
+}
+
+int GetAccountingReportResult::getPageNumber()const
+{
+	return pageNumber_;
+}
+
+std::vector<std::string> GetAccountingReportResult::getData()const
+{
+	return data_;
+}
+
+int GetAccountingReportResult::getTotalCoreTime()const
+{
+	return totalCoreTime_;
+}
+

ehpc/src/model/GetAutoScaleConfigRequest.cc

@@ -19,7 +19,7 @@
 using AlibabaCloud::EHPC::Model::GetAutoScaleConfigRequest;
 
 GetAutoScaleConfigRequest::GetAutoScaleConfigRequest()
-    : RpcServiceRequest("ehpc", "2017-07-14", "GetAutoScaleConfig") {
+    : RpcServiceRequest("ehpc", "2018-04-12", "GetAutoScaleConfig") {
   setMethod(HttpRequest::Method::Get);
 }
 

ehpc/src/model/GetAutoScaleConfigResult.cc

@@ -39,32 +39,114 @@ void GetAutoScaleConfigResult::parse(const std::string &payload)
 	Json::Value value;
 	reader.parse(payload, value);
 	setRequestId(value["RequestId"].asString());
+	auto allQueuesNode = value["Queues"]["QueueInfo"];
+	for (auto valueQueuesQueueInfo : allQueuesNode)
+	{
+		QueueInfo queuesObject;
+		if(!valueQueuesQueueInfo["QueueImageId"].isNull())
+			queuesObject.queueImageId = valueQueuesQueueInfo["QueueImageId"].asString();
+		if(!valueQueuesQueueInfo["SystemDiskCategory"].isNull())
+			queuesObject.systemDiskCategory = valueQueuesQueueInfo["SystemDiskCategory"].asString();
+		if(!valueQueuesQueueInfo["InstanceType"].isNull())
+			queuesObject.instanceType = valueQueuesQueueInfo["InstanceType"].asString();
+		if(!valueQueuesQueueInfo["HostNameSuffix"].isNull())
+			queuesObject.hostNameSuffix = valueQueuesQueueInfo["HostNameSuffix"].asString();
+		if(!valueQueuesQueueInfo["SpotStrategy"].isNull())
+			queuesObject.spotStrategy = valueQueuesQueueInfo["SpotStrategy"].asString();
+		if(!valueQueuesQueueInfo["MinNodesInQueue"].isNull())
+			queuesObject.minNodesInQueue = std::stoi(valueQueuesQueueInfo["MinNodesInQueue"].asString());
+		if(!valueQueuesQueueInfo["HostNamePrefix"].isNull())
+			queuesObject.hostNamePrefix = valueQueuesQueueInfo["HostNamePrefix"].asString();
+		if(!valueQueuesQueueInfo["SystemDiskSize"].isNull())
+			queuesObject.systemDiskSize = std::stoi(valueQueuesQueueInfo["SystemDiskSize"].asString());
+		if(!valueQueuesQueueInfo["MaxNodesInQueue"].isNull())
+			queuesObject.maxNodesInQueue = std::stoi(valueQueuesQueueInfo["MaxNodesInQueue"].asString());
+		if(!valueQueuesQueueInfo["EnableAutoShrink"].isNull())
+			queuesObject.enableAutoShrink = valueQueuesQueueInfo["EnableAutoShrink"].asString() == "true";
+		if(!valueQueuesQueueInfo["QueueName"].isNull())
+			queuesObject.queueName = valueQueuesQueueInfo["QueueName"].asString();
+		if(!valueQueuesQueueInfo["EnableAutoGrow"].isNull())
+			queuesObject.enableAutoGrow = valueQueuesQueueInfo["EnableAutoGrow"].asString() == "true";
+		if(!valueQueuesQueueInfo["SystemDiskLevel"].isNull())
+			queuesObject.systemDiskLevel = valueQueuesQueueInfo["SystemDiskLevel"].asString();
+		if(!valueQueuesQueueInfo["ResourceGroupId"].isNull())
+			queuesObject.resourceGroupId = valueQueuesQueueInfo["ResourceGroupId"].asString();
+		if(!valueQueuesQueueInfo["SpotPriceLimit"].isNull())
+			queuesObject.spotPriceLimit = std::stof(valueQueuesQueueInfo["SpotPriceLimit"].asString());
+		if(!valueQueuesQueueInfo["MaxNodesPerCycle"].isNull())
+			queuesObject.maxNodesPerCycle = std::stol(valueQueuesQueueInfo["MaxNodesPerCycle"].asString());
+		if(!valueQueuesQueueInfo["MinNodesPerCycle"].isNull())
+			queuesObject.minNodesPerCycle = std::stol(valueQueuesQueueInfo["MinNodesPerCycle"].asString());
+		auto allInstanceTypesNode = valueQueuesQueueInfo["InstanceTypes"]["InstanceTypeInfo"];
+		for (auto valueQueuesQueueInfoInstanceTypesInstanceTypeInfo : allInstanceTypesNode)
+		{
+			QueueInfo::InstanceTypeInfo instanceTypesObject;
+			if(!valueQueuesQueueInfoInstanceTypesInstanceTypeInfo["HostNamePrefix"].isNull())
+				instanceTypesObject.hostNamePrefix = valueQueuesQueueInfoInstanceTypesInstanceTypeInfo["HostNamePrefix"].asString();
+			if(!valueQueuesQueueInfoInstanceTypesInstanceTypeInfo["VSwitchId"].isNull())
+				instanceTypesObject.vSwitchId = valueQueuesQueueInfoInstanceTypesInstanceTypeInfo["VSwitchId"].asString();
+			if(!valueQueuesQueueInfoInstanceTypesInstanceTypeInfo["ZoneId"].isNull())
+				instanceTypesObject.zoneId = valueQueuesQueueInfoInstanceTypesInstanceTypeInfo["ZoneId"].asString();
+			if(!valueQueuesQueueInfoInstanceTypesInstanceTypeInfo["SpotPriceLimit"].isNull())
+				instanceTypesObject.spotPriceLimit = std::stof(valueQueuesQueueInfoInstanceTypesInstanceTypeInfo["SpotPriceLimit"].asString());
+			if(!valueQueuesQueueInfoInstanceTypesInstanceTypeInfo["InstanceType"].isNull())
+				instanceTypesObject.instanceType = valueQueuesQueueInfoInstanceTypesInstanceTypeInfo["InstanceType"].asString();
+			if(!valueQueuesQueueInfoInstanceTypesInstanceTypeInfo["SpotStrategy"].isNull())
+				instanceTypesObject.spotStrategy = valueQueuesQueueInfoInstanceTypesInstanceTypeInfo["SpotStrategy"].asString();
+			queuesObject.instanceTypes.push_back(instanceTypesObject);
+		}
+		auto allDataDisksNode = valueQueuesQueueInfo["DataDisks"]["DataDisksInfo"];
+		for (auto valueQueuesQueueInfoDataDisksDataDisksInfo : allDataDisksNode)
+		{
+			QueueInfo::DataDisksInfo dataDisksObject;
+			if(!valueQueuesQueueInfoDataDisksDataDisksInfo["DataDiskCategory"].isNull())
+				dataDisksObject.dataDiskCategory = valueQueuesQueueInfoDataDisksDataDisksInfo["DataDiskCategory"].asString();
+			if(!valueQueuesQueueInfoDataDisksDataDisksInfo["DataDiskSize"].isNull())
+				dataDisksObject.dataDiskSize = std::stoi(valueQueuesQueueInfoDataDisksDataDisksInfo["DataDiskSize"].asString());
+			if(!valueQueuesQueueInfoDataDisksDataDisksInfo["DataDiskDeleteWithInstance"].isNull())
+				dataDisksObject.dataDiskDeleteWithInstance = valueQueuesQueueInfoDataDisksDataDisksInfo["DataDiskDeleteWithInstance"].asString() == "true";
+			if(!valueQueuesQueueInfoDataDisksDataDisksInfo["DataDiskPerformanceLevel"].isNull())
+				dataDisksObject.dataDiskPerformanceLevel = valueQueuesQueueInfoDataDisksDataDisksInfo["DataDiskPerformanceLevel"].asString();
+			if(!valueQueuesQueueInfoDataDisksDataDisksInfo["DataDiskEncrypted"].isNull())
+				dataDisksObject.dataDiskEncrypted = valueQueuesQueueInfoDataDisksDataDisksInfo["DataDiskEncrypted"].asString() == "true";
+			if(!valueQueuesQueueInfoDataDisksDataDisksInfo["DataDiskKMSKeyId"].isNull())
+				dataDisksObject.dataDiskKMSKeyId = valueQueuesQueueInfoDataDisksDataDisksInfo["DataDiskKMSKeyId"].asString();
+			queuesObject.dataDisks.push_back(dataDisksObject);
+		}
+		queues_.push_back(queuesObject);
+	}
 	if(!value["MaxNodesInCluster"].isNull())
 		maxNodesInCluster_ = std::stoi(value["MaxNodesInCluster"].asString());
 	if(!value["GrowTimeoutInMinutes"].isNull())
 		growTimeoutInMinutes_ = std::stoi(value["GrowTimeoutInMinutes"].asString());
+	if(!value["SpotStrategy"].isNull())
+		spotStrategy_ = value["SpotStrategy"].asString();
 	if(!value["EnableAutoShrink"].isNull())
 		enableAutoShrink_ = value["EnableAutoShrink"].asString() == "true";
-	if(!value["ClusterType"].isNull())
-		clusterType_ = value["ClusterType"].asString();
 	if(!value["EnableAutoGrow"].isNull())
 		enableAutoGrow_ = value["EnableAutoGrow"].asString() == "true";
+	if(!value["ClusterType"].isNull())
+		clusterType_ = value["ClusterType"].asString();
 	if(!value["ExcludeNodes"].isNull())
 		excludeNodes_ = value["ExcludeNodes"].asString();
-	if(!value["GrowIntervalInMinutes"].isNull())
-		growIntervalInMinutes_ = std::stoi(value["GrowIntervalInMinutes"].asString());
 	if(!value["ShrinkIntervalInMinutes"].isNull())
 		shrinkIntervalInMinutes_ = std::stoi(value["ShrinkIntervalInMinutes"].asString());
-	if(!value["ShrinkIdleTimes"].isNull())
-		shrinkIdleTimes_ = std::stoi(value["ShrinkIdleTimes"].asString());
+	if(!value["GrowIntervalInMinutes"].isNull())
+		growIntervalInMinutes_ = std::stoi(value["GrowIntervalInMinutes"].asString());
+	if(!value["SpotPriceLimit"].isNull())
+		spotPriceLimit_ = std::stof(value["SpotPriceLimit"].asString());
 	if(!value["ExtraNodesGrowRatio"].isNull())
 		extraNodesGrowRatio_ = std::stoi(value["ExtraNodesGrowRatio"].asString());
+	if(!value["ShrinkIdleTimes"].isNull())
+		shrinkIdleTimes_ = std::stoi(value["ShrinkIdleTimes"].asString());
+	if(!value["ImageId"].isNull())
+		imageId_ = value["ImageId"].asString();
 	if(!value["GrowRatio"].isNull())
 		growRatio_ = std::stoi(value["GrowRatio"].asString());
-	if(!value["Uid"].isNull())
-		uid_ = value["Uid"].asString();
 	if(!value["ClusterId"].isNull())
 		clusterId_ = value["ClusterId"].asString();
+	if(!value["Uid"].isNull())
+		uid_ = value["Uid"].asString();
 
 }
 
@@ -123,13 +205,33 @@ int GetAutoScaleConfigResult::getGrowTimeoutInMinutes()const
 	return growTimeoutInMinutes_;
 }
 
+std::string GetAutoScaleConfigResult::getImageId()const
+{
+	return imageId_;
+}
+
 int GetAutoScaleConfigResult::getShrinkIntervalInMinutes()const
 {
 	return shrinkIntervalInMinutes_;
 }
 
+float GetAutoScaleConfigResult::getSpotPriceLimit()const
+{
+	return spotPriceLimit_;
+}
+
+std::vector<GetAutoScaleConfigResult::QueueInfo> GetAutoScaleConfigResult::getQueues()const
+{
+	return queues_;
+}
+
 std::string GetAutoScaleConfigResult::getExcludeNodes()const
 {
 	return excludeNodes_;
 }
 
+std::string GetAutoScaleConfigResult::getSpotStrategy()const
+{
+	return spotStrategy_;
+}
+

ehpc/src/model/GetCloudMetricLogsRequest.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/ehpc/model/GetCloudMetricLogsRequest.h>
+
+using AlibabaCloud::EHPC::Model::GetCloudMetricLogsRequest;
+
+GetCloudMetricLogsRequest::GetCloudMetricLogsRequest()
+    : RpcServiceRequest("ehpc", "2018-04-12", "GetCloudMetricLogs") {
+  setMethod(HttpRequest::Method::Get);
+}
+
+GetCloudMetricLogsRequest::~GetCloudMetricLogsRequest() {}
+
+std::string GetCloudMetricLogsRequest::getMetricScope() const {
+  return metricScope_;
+}
+
+void GetCloudMetricLogsRequest::setMetricScope(const std::string &metricScope) {
+  metricScope_ = metricScope;
+  setParameter(std::string("MetricScope"), metricScope);
+}
+
+std::string GetCloudMetricLogsRequest::getClusterId() const {
+  return clusterId_;
+}
+
+void GetCloudMetricLogsRequest::setClusterId(const std::string &clusterId) {
+  clusterId_ = clusterId;
+  setParameter(std::string("ClusterId"), clusterId);
+}
+
+int GetCloudMetricLogsRequest::getAggregationInterval() const {
+  return aggregationInterval_;
+}
+
+void GetCloudMetricLogsRequest::setAggregationInterval(int aggregationInterval) {
+  aggregationInterval_ = aggregationInterval;
+  setParameter(std::string("AggregationInterval"), std::to_string(aggregationInterval));
+}
+
+bool GetCloudMetricLogsRequest::getReverse() const {
+  return reverse_;
+}
+
+void GetCloudMetricLogsRequest::setReverse(bool reverse) {
+  reverse_ = reverse;
+  setParameter(std::string("Reverse"), reverse ? "true" : "false");
+}
+
+std::string GetCloudMetricLogsRequest::getAccessKeyId() const {
+  return accessKeyId_;
+}
+
+void GetCloudMetricLogsRequest::setAccessKeyId(const std::string &accessKeyId) {
+  accessKeyId_ = accessKeyId;
+  setParameter(std::string("AccessKeyId"), accessKeyId);
+}
+
+std::string GetCloudMetricLogsRequest::getAggregationType() const {
+  return aggregationType_;
+}
+
+void GetCloudMetricLogsRequest::setAggregationType(const std::string &aggregationType) {
+  aggregationType_ = aggregationType;
+  setParameter(std::string("AggregationType"), aggregationType);
+}
+
+std::string GetCloudMetricLogsRequest::getFilter() const {
+  return filter_;
+}
+
+void GetCloudMetricLogsRequest::setFilter(const std::string &filter) {
+  filter_ = filter;
+  setParameter(std::string("Filter"), filter);
+}
+
+std::string GetCloudMetricLogsRequest::getMetricCategories() const {
+  return metricCategories_;
+}
+
+void GetCloudMetricLogsRequest::setMetricCategories(const std::string &metricCategories) {
+  metricCategories_ = metricCategories;
+  setParameter(std::string("MetricCategories"), metricCategories);
+}
+
+int GetCloudMetricLogsRequest::getFrom() const {
+  return from_;
+}
+
+void GetCloudMetricLogsRequest::setFrom(int from) {
+  from_ = from;
+  setParameter(std::string("From"), std::to_string(from));
+}
+
+int GetCloudMetricLogsRequest::getTo() const {
+  return to_;
+}
+
+void GetCloudMetricLogsRequest::setTo(int to) {
+  to_ = to;
+  setParameter(std::string("To"), std::to_string(to));
+}
+

ehpc/src/model/GetCloudMetricLogsResult.cc

@@ -0,0 +1,67 @@
+/*
+ * 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/ehpc/model/GetCloudMetricLogsResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::EHPC;
+using namespace AlibabaCloud::EHPC::Model;
+
+GetCloudMetricLogsResult::GetCloudMetricLogsResult() :
+	ServiceResult()
+{}
+
+GetCloudMetricLogsResult::GetCloudMetricLogsResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+GetCloudMetricLogsResult::~GetCloudMetricLogsResult()
+{}
+
+void GetCloudMetricLogsResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto allMetricLogsNode = value["MetricLogs"]["MetricLog"];
+	for (auto valueMetricLogsMetricLog : allMetricLogsNode)
+	{
+		MetricLog metricLogsObject;
+		if(!valueMetricLogsMetricLog["Time"].isNull())
+			metricLogsObject.time = std::stoi(valueMetricLogsMetricLog["Time"].asString());
+		if(!valueMetricLogsMetricLog["DiskDevice"].isNull())
+			metricLogsObject.diskDevice = valueMetricLogsMetricLog["DiskDevice"].asString();
+		if(!valueMetricLogsMetricLog["NetworkInterface"].isNull())
+			metricLogsObject.networkInterface = valueMetricLogsMetricLog["NetworkInterface"].asString();
+		if(!valueMetricLogsMetricLog["MetricData"].isNull())
+			metricLogsObject.metricData = valueMetricLogsMetricLog["MetricData"].asString();
+		if(!valueMetricLogsMetricLog["Hostname"].isNull())
+			metricLogsObject.hostname = valueMetricLogsMetricLog["Hostname"].asString();
+		if(!valueMetricLogsMetricLog["InstanceId"].isNull())
+			metricLogsObject.instanceId = valueMetricLogsMetricLog["InstanceId"].asString();
+		metricLogs_.push_back(metricLogsObject);
+	}
+
+}
+
+std::vector<GetCloudMetricLogsResult::MetricLog> GetCloudMetricLogsResult::getMetricLogs()const
+{
+	return metricLogs_;
+}
+

ehpc/src/model/GetCloudMetricProfilingRequest.cc

@@ -0,0 +1,63 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/ehpc/model/GetCloudMetricProfilingRequest.h>
+
+using AlibabaCloud::EHPC::Model::GetCloudMetricProfilingRequest;
+
+GetCloudMetricProfilingRequest::GetCloudMetricProfilingRequest()
+    : RpcServiceRequest("ehpc", "2018-04-12", "GetCloudMetricProfiling") {
+  setMethod(HttpRequest::Method::Get);
+}
+
+GetCloudMetricProfilingRequest::~GetCloudMetricProfilingRequest() {}
+
+std::string GetCloudMetricProfilingRequest::getClusterId() const {
+  return clusterId_;
+}
+
+void GetCloudMetricProfilingRequest::setClusterId(const std::string &clusterId) {
+  clusterId_ = clusterId;
+  setParameter(std::string("ClusterId"), clusterId);
+}
+
+std::string GetCloudMetricProfilingRequest::getAccessKeyId() const {
+  return accessKeyId_;
+}
+
+void GetCloudMetricProfilingRequest::setAccessKeyId(const std::string &accessKeyId) {
+  accessKeyId_ = accessKeyId;
+  setParameter(std::string("AccessKeyId"), accessKeyId);
+}
+
+std::string GetCloudMetricProfilingRequest::getRegionId() const {
+  return regionId_;
+}
+
+void GetCloudMetricProfilingRequest::setRegionId(const std::string &regionId) {
+  regionId_ = regionId;
+  setParameter(std::string("RegionId"), regionId);
+}
+
+std::string GetCloudMetricProfilingRequest::getProfilingId() const {
+  return profilingId_;
+}
+
+void GetCloudMetricProfilingRequest::setProfilingId(const std::string &profilingId) {
+  profilingId_ = profilingId;
+  setParameter(std::string("ProfilingId"), profilingId);
+}
+

ehpc/src/model/GetCloudMetricProfilingResult.cc

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

ehpc/src/model/GetClusterVolumesRequest.cc

@@ -0,0 +1,45 @@
+/*
+ * 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/ehpc/model/GetClusterVolumesRequest.h>
+
+using AlibabaCloud::EHPC::Model::GetClusterVolumesRequest;
+
+GetClusterVolumesRequest::GetClusterVolumesRequest()
+    : RpcServiceRequest("ehpc", "2018-04-12", "GetClusterVolumes") {
+  setMethod(HttpRequest::Method::Get);
+}
+
+GetClusterVolumesRequest::~GetClusterVolumesRequest() {}
+
+std::string GetClusterVolumesRequest::getClusterId() const {
+  return clusterId_;
+}
+
+void GetClusterVolumesRequest::setClusterId(const std::string &clusterId) {
+  clusterId_ = clusterId;
+  setParameter(std::string("ClusterId"), clusterId);
+}
+
+std::string GetClusterVolumesRequest::getAccessKeyId() const {
+  return accessKeyId_;
+}
+
+void GetClusterVolumesRequest::setAccessKeyId(const std::string &accessKeyId) {
+  accessKeyId_ = accessKeyId;
+  setParameter(std::string("AccessKeyId"), accessKeyId);
+}
+

ehpc/src/model/GetClusterVolumesResult.cc

@@ -0,0 +1,88 @@
+/*
+ * 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/ehpc/model/GetClusterVolumesResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::EHPC;
+using namespace AlibabaCloud::EHPC::Model;
+
+GetClusterVolumesResult::GetClusterVolumesResult() :
+	ServiceResult()
+{}
+
+GetClusterVolumesResult::GetClusterVolumesResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+GetClusterVolumesResult::~GetClusterVolumesResult()
+{}
+
+void GetClusterVolumesResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto allVolumesNode = value["Volumes"]["VolumeInfo"];
+	for (auto valueVolumesVolumeInfo : allVolumesNode)
+	{
+		VolumeInfo volumesObject;
+		if(!valueVolumesVolumeInfo["JobQueue"].isNull())
+			volumesObject.jobQueue = valueVolumesVolumeInfo["JobQueue"].asString();
+		if(!valueVolumesVolumeInfo["VolumeId"].isNull())
+			volumesObject.volumeId = valueVolumesVolumeInfo["VolumeId"].asString();
+		if(!valueVolumesVolumeInfo["RemoteDirectory"].isNull())
+			volumesObject.remoteDirectory = valueVolumesVolumeInfo["RemoteDirectory"].asString();
+		if(!valueVolumesVolumeInfo["VolumeMountpoint"].isNull())
+			volumesObject.volumeMountpoint = valueVolumesVolumeInfo["VolumeMountpoint"].asString();
+		if(!valueVolumesVolumeInfo["LocalDirectory"].isNull())
+			volumesObject.localDirectory = valueVolumesVolumeInfo["LocalDirectory"].asString();
+		if(!valueVolumesVolumeInfo["VolumeType"].isNull())
+			volumesObject.volumeType = valueVolumesVolumeInfo["VolumeType"].asString();
+		if(!valueVolumesVolumeInfo["MustKeep"].isNull())
+			volumesObject.mustKeep = valueVolumesVolumeInfo["MustKeep"].asString() == "true";
+		if(!valueVolumesVolumeInfo["Location"].isNull())
+			volumesObject.location = valueVolumesVolumeInfo["Location"].asString();
+		if(!valueVolumesVolumeInfo["VolumeProtocol"].isNull())
+			volumesObject.volumeProtocol = valueVolumesVolumeInfo["VolumeProtocol"].asString();
+		auto allRolesNode = valueVolumesVolumeInfo["Roles"]["RoleInfo"];
+		for (auto valueVolumesVolumeInfoRolesRoleInfo : allRolesNode)
+		{
+			VolumeInfo::RoleInfo rolesObject;
+			if(!valueVolumesVolumeInfoRolesRoleInfo["Name"].isNull())
+				rolesObject.name = valueVolumesVolumeInfoRolesRoleInfo["Name"].asString();
+			volumesObject.roles.push_back(rolesObject);
+		}
+		volumes_.push_back(volumesObject);
+	}
+	if(!value["RegionId"].isNull())
+		regionId_ = value["RegionId"].asString();
+
+}
+
+std::vector<GetClusterVolumesResult::VolumeInfo> GetClusterVolumesResult::getVolumes()const
+{
+	return volumes_;
+}
+
+std::string GetClusterVolumesResult::getRegionId()const
+{
+	return regionId_;
+}
+

ehpc/src/model/GetCommonImageRequest.cc

@@ -0,0 +1,63 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/ehpc/model/GetCommonImageRequest.h>
+
+using AlibabaCloud::EHPC::Model::GetCommonImageRequest;
+
+GetCommonImageRequest::GetCommonImageRequest()
+    : RpcServiceRequest("ehpc", "2018-04-12", "GetCommonImage") {
+  setMethod(HttpRequest::Method::Get);
+}
+
+GetCommonImageRequest::~GetCommonImageRequest() {}
+
+std::string GetCommonImageRequest::getContainType() const {
+  return containType_;
+}
+
+void GetCommonImageRequest::setContainType(const std::string &containType) {
+  containType_ = containType;
+  setParameter(std::string("ContainType"), containType);
+}
+
+std::string GetCommonImageRequest::getClusterId() const {
+  return clusterId_;
+}
+
+void GetCommonImageRequest::setClusterId(const std::string &clusterId) {
+  clusterId_ = clusterId;
+  setParameter(std::string("ClusterId"), clusterId);
+}
+
+std::string GetCommonImageRequest::getImageName() const {
+  return imageName_;
+}
+
+void GetCommonImageRequest::setImageName(const std::string &imageName) {
+  imageName_ = imageName;
+  setParameter(std::string("ImageName"), imageName);
+}
+
+std::string GetCommonImageRequest::getRegionId() const {
+  return regionId_;
+}
+
+void GetCommonImageRequest::setRegionId(const std::string &regionId) {
+  regionId_ = regionId;
+  setParameter(std::string("RegionId"), regionId);
+}
+

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

ehpc/src/model/GetGWSConnectTicketRequest.cc

@@ -0,0 +1,54 @@
+/*
+ * 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/ehpc/model/GetGWSConnectTicketRequest.h>
+
+using AlibabaCloud::EHPC::Model::GetGWSConnectTicketRequest;
+
+GetGWSConnectTicketRequest::GetGWSConnectTicketRequest()
+    : RpcServiceRequest("ehpc", "2018-04-12", "GetGWSConnectTicket") {
+  setMethod(HttpRequest::Method::Get);
+}
+
+GetGWSConnectTicketRequest::~GetGWSConnectTicketRequest() {}
+
+std::string GetGWSConnectTicketRequest::getAccessKeyId() const {
+  return accessKeyId_;
+}
+
+void GetGWSConnectTicketRequest::setAccessKeyId(const std::string &accessKeyId) {
+  accessKeyId_ = accessKeyId;
+  setParameter(std::string("AccessKeyId"), accessKeyId);
+}
+
+std::string GetGWSConnectTicketRequest::getInstanceId() const {
+  return instanceId_;
+}
+
+void GetGWSConnectTicketRequest::setInstanceId(const std::string &instanceId) {
+  instanceId_ = instanceId;
+  setParameter(std::string("InstanceId"), instanceId);
+}
+
+std::string GetGWSConnectTicketRequest::getAppName() const {
+  return appName_;
+}
+
+void GetGWSConnectTicketRequest::setAppName(const std::string &appName) {
+  appName_ = appName;
+  setParameter(std::string("AppName"), appName);
+}
+

ehpc/src/model/GetGWSConnectTicketResult.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/ehpc/model/GetGWSConnectTicketResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::EHPC;
+using namespace AlibabaCloud::EHPC::Model;
+
+GetGWSConnectTicketResult::GetGWSConnectTicketResult() :
+	ServiceResult()
+{}
+
+GetGWSConnectTicketResult::GetGWSConnectTicketResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+GetGWSConnectTicketResult::~GetGWSConnectTicketResult()
+{}
+
+void GetGWSConnectTicketResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	if(!value["Ticket"].isNull())
+		ticket_ = value["Ticket"].asString();
+
+}
+
+std::string GetGWSConnectTicketResult::getTicket()const
+{
+	return ticket_;
+}
+

ehpc/src/model/GetHybridClusterConfigRequest.cc

@@ -0,0 +1,54 @@
+/*
+ * 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/ehpc/model/GetHybridClusterConfigRequest.h>
+
+using AlibabaCloud::EHPC::Model::GetHybridClusterConfigRequest;
+
+GetHybridClusterConfigRequest::GetHybridClusterConfigRequest()
+    : RpcServiceRequest("ehpc", "2018-04-12", "GetHybridClusterConfig") {
+  setMethod(HttpRequest::Method::Get);
+}
+
+GetHybridClusterConfigRequest::~GetHybridClusterConfigRequest() {}
+
+std::string GetHybridClusterConfigRequest::getClusterId() const {
+  return clusterId_;
+}
+
+void GetHybridClusterConfigRequest::setClusterId(const std::string &clusterId) {
+  clusterId_ = clusterId;
+  setParameter(std::string("ClusterId"), clusterId);
+}
+
+std::string GetHybridClusterConfigRequest::getAccessKeyId() const {
+  return accessKeyId_;
+}
+
+void GetHybridClusterConfigRequest::setAccessKeyId(const std::string &accessKeyId) {
+  accessKeyId_ = accessKeyId;
+  setParameter(std::string("AccessKeyId"), accessKeyId);
+}
+
+std::string GetHybridClusterConfigRequest::getNode() const {
+  return node_;
+}
+
+void GetHybridClusterConfigRequest::setNode(const std::string &node) {
+  node_ = node;
+  setParameter(std::string("Node"), node);
+}
+

ehpc/src/model/GetHybridClusterConfigResult.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/ehpc/model/GetHybridClusterConfigResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::EHPC;
+using namespace AlibabaCloud::EHPC::Model;
+
+GetHybridClusterConfigResult::GetHybridClusterConfigResult() :
+	ServiceResult()
+{}
+
+GetHybridClusterConfigResult::GetHybridClusterConfigResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+GetHybridClusterConfigResult::~GetHybridClusterConfigResult()
+{}
+
+void GetHybridClusterConfigResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	if(!value["ClusterConfig"].isNull())
+		clusterConfig_ = value["ClusterConfig"].asString();
+
+}
+
+std::string GetHybridClusterConfigResult::getClusterConfig()const
+{
+	return clusterConfig_;
+}
+

ehpc/src/model/GetIfEcsTypeSupportHtConfigRequest.cc

@@ -0,0 +1,45 @@
+/*
+ * 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/ehpc/model/GetIfEcsTypeSupportHtConfigRequest.h>
+
+using AlibabaCloud::EHPC::Model::GetIfEcsTypeSupportHtConfigRequest;
+
+GetIfEcsTypeSupportHtConfigRequest::GetIfEcsTypeSupportHtConfigRequest()
+    : RpcServiceRequest("ehpc", "2018-04-12", "GetIfEcsTypeSupportHtConfig") {
+  setMethod(HttpRequest::Method::Get);
+}
+
+GetIfEcsTypeSupportHtConfigRequest::~GetIfEcsTypeSupportHtConfigRequest() {}
+
+std::string GetIfEcsTypeSupportHtConfigRequest::getAccessKeyId() const {
+  return accessKeyId_;
+}
+
+void GetIfEcsTypeSupportHtConfigRequest::setAccessKeyId(const std::string &accessKeyId) {
+  accessKeyId_ = accessKeyId;
+  setParameter(std::string("AccessKeyId"), accessKeyId);
+}
+
+std::string GetIfEcsTypeSupportHtConfigRequest::getInstanceType() const {
+  return instanceType_;
+}
+
+void GetIfEcsTypeSupportHtConfigRequest::setInstanceType(const std::string &instanceType) {
+  instanceType_ = instanceType;
+  setParameter(std::string("InstanceType"), instanceType);
+}
+

ehpc/src/model/GetIfEcsTypeSupportHtConfigResult.cc

@@ -0,0 +1,65 @@
+/*
+ * 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/ehpc/model/GetIfEcsTypeSupportHtConfigResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::EHPC;
+using namespace AlibabaCloud::EHPC::Model;
+
+GetIfEcsTypeSupportHtConfigResult::GetIfEcsTypeSupportHtConfigResult() :
+	ServiceResult()
+{}
+
+GetIfEcsTypeSupportHtConfigResult::GetIfEcsTypeSupportHtConfigResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+GetIfEcsTypeSupportHtConfigResult::~GetIfEcsTypeSupportHtConfigResult()
+{}
+
+void GetIfEcsTypeSupportHtConfigResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	if(!value["DefaultHtEnabled"].isNull())
+		defaultHtEnabled_ = value["DefaultHtEnabled"].asString() == "true";
+	if(!value["InstanceType"].isNull())
+		instanceType_ = value["InstanceType"].asString();
+	if(!value["SupportHtConfig"].isNull())
+		supportHtConfig_ = value["SupportHtConfig"].asString() == "true";
+
+}
+
+bool GetIfEcsTypeSupportHtConfigResult::getDefaultHtEnabled()const
+{
+	return defaultHtEnabled_;
+}
+
+bool GetIfEcsTypeSupportHtConfigResult::getSupportHtConfig()const
+{
+	return supportHtConfig_;
+}
+
+std::string GetIfEcsTypeSupportHtConfigResult::getInstanceType()const
+{
+	return instanceType_;
+}
+

ehpc/src/model/GetPostScriptsRequest.cc

@@ -0,0 +1,54 @@
+/*
+ * 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/ehpc/model/GetPostScriptsRequest.h>
+
+using AlibabaCloud::EHPC::Model::GetPostScriptsRequest;
+
+GetPostScriptsRequest::GetPostScriptsRequest()
+    : RpcServiceRequest("ehpc", "2018-04-12", "GetPostScripts") {
+  setMethod(HttpRequest::Method::Get);
+}
+
+GetPostScriptsRequest::~GetPostScriptsRequest() {}
+
+std::string GetPostScriptsRequest::getClusterId() const {
+  return clusterId_;
+}
+
+void GetPostScriptsRequest::setClusterId(const std::string &clusterId) {
+  clusterId_ = clusterId;
+  setParameter(std::string("ClusterId"), clusterId);
+}
+
+std::string GetPostScriptsRequest::getAccessKeyId() const {
+  return accessKeyId_;
+}
+
+void GetPostScriptsRequest::setAccessKeyId(const std::string &accessKeyId) {
+  accessKeyId_ = accessKeyId;
+  setParameter(std::string("AccessKeyId"), accessKeyId);
+}
+
+std::string GetPostScriptsRequest::getRegionId() const {
+  return regionId_;
+}
+
+void GetPostScriptsRequest::setRegionId(const std::string &regionId) {
+  regionId_ = regionId;
+  setParameter(std::string("RegionId"), regionId);
+}
+

ehpc/src/model/GetPostScriptsResult.cc

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

ehpc/src/model/GetSchedulerInfoRequest.cc

@@ -0,0 +1,67 @@
+/*
+ * 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/ehpc/model/GetSchedulerInfoRequest.h>
+
+using AlibabaCloud::EHPC::Model::GetSchedulerInfoRequest;
+
+GetSchedulerInfoRequest::GetSchedulerInfoRequest()
+    : RpcServiceRequest("ehpc", "2018-04-12", "GetSchedulerInfo") {
+  setMethod(HttpRequest::Method::Get);
+}
+
+GetSchedulerInfoRequest::~GetSchedulerInfoRequest() {}
+
+std::string GetSchedulerInfoRequest::getClusterId() const {
+  return clusterId_;
+}
+
+void GetSchedulerInfoRequest::setClusterId(const std::string &clusterId) {
+  clusterId_ = clusterId;
+  setParameter(std::string("ClusterId"), clusterId);
+}
+
+std::string GetSchedulerInfoRequest::getAccessKeyId() const {
+  return accessKeyId_;
+}
+
+void GetSchedulerInfoRequest::setAccessKeyId(const std::string &accessKeyId) {
+  accessKeyId_ = accessKeyId;
+  setParameter(std::string("AccessKeyId"), accessKeyId);
+}
+
+std::vector<GetSchedulerInfoRequest::Scheduler> GetSchedulerInfoRequest::getScheduler() const {
+  return scheduler_;
+}
+
+void GetSchedulerInfoRequest::setScheduler(const std::vector<GetSchedulerInfoRequest::Scheduler> &scheduler) {
+  scheduler_ = scheduler;
+  for(int dep1 = 0; dep1 != scheduler.size(); dep1++) {
+  auto schedulerObj = scheduler.at(dep1);
+  std::string schedulerObjStr = std::string("Scheduler") + "." + std::to_string(dep1 + 1);
+    setParameter(schedulerObjStr + ".SchedName", schedulerObj.schedName);
+  }
+}
+
+std::string GetSchedulerInfoRequest::getRegionId() const {
+  return regionId_;
+}
+
+void GetSchedulerInfoRequest::setRegionId(const std::string &regionId) {
+  regionId_ = regionId;
+  setParameter(std::string("RegionId"), regionId);
+}
+