Support MinCount for AddNodes.

CHANGELOG

@@ -1,3 +1,7 @@
+2021-05-18 Version: 1.36.742
+- Support MinCount for AddNodes.
+- Support HostNamePreffix and HostNameSuffix for ListNodes.
+
 2021-05-17 Version: 1.36.741
 - Add API ListQuotaReviewTasks.
 

VERSION

@@ -1 +1 @@
-1.36.741
+1.36.742

ehpc/CMakeLists.txt

@@ -23,6 +23,8 @@ set(ehpc_public_header
 set(ehpc_public_header_model 
 	include/alibabacloud/ehpc/model/AddContainerAppRequest.h
 	include/alibabacloud/ehpc/model/AddContainerAppResult.h
+	include/alibabacloud/ehpc/model/AddExistedNodesRequest.h
+	include/alibabacloud/ehpc/model/AddExistedNodesResult.h
 	include/alibabacloud/ehpc/model/AddLocalNodesRequest.h
 	include/alibabacloud/ehpc/model/AddLocalNodesResult.h
 	include/alibabacloud/ehpc/model/AddNodesRequest.h
@@ -99,6 +101,8 @@ set(ehpc_public_header_model
 	include/alibabacloud/ehpc/model/DescribeNFSClientStatusResult.h
 	include/alibabacloud/ehpc/model/DescribePriceRequest.h
 	include/alibabacloud/ehpc/model/DescribePriceResult.h
+	include/alibabacloud/ehpc/model/EcdDeleteDesktopsRequest.h
+	include/alibabacloud/ehpc/model/EcdDeleteDesktopsResult.h
 	include/alibabacloud/ehpc/model/EditJobTemplateRequest.h
 	include/alibabacloud/ehpc/model/EditJobTemplateResult.h
 	include/alibabacloud/ehpc/model/GetAccountingReportRequest.h
@@ -264,6 +268,8 @@ set(ehpc_src
 	src/EHPCClient.cc
 	src/model/AddContainerAppRequest.cc
 	src/model/AddContainerAppResult.cc
+	src/model/AddExistedNodesRequest.cc
+	src/model/AddExistedNodesResult.cc
 	src/model/AddLocalNodesRequest.cc
 	src/model/AddLocalNodesResult.cc
 	src/model/AddNodesRequest.cc
@@ -340,6 +346,8 @@ set(ehpc_src
 	src/model/DescribeNFSClientStatusResult.cc
 	src/model/DescribePriceRequest.cc
 	src/model/DescribePriceResult.cc
+	src/model/EcdDeleteDesktopsRequest.cc
+	src/model/EcdDeleteDesktopsResult.cc
 	src/model/EditJobTemplateRequest.cc
 	src/model/EditJobTemplateResult.cc
 	src/model/GetAccountingReportRequest.cc

ehpc/include/alibabacloud/ehpc/EHPCClient.h

@@ -24,6 +24,8 @@
 #include "EHPCExport.h"
 #include "model/AddContainerAppRequest.h"
 #include "model/AddContainerAppResult.h"
+#include "model/AddExistedNodesRequest.h"
+#include "model/AddExistedNodesResult.h"
 #include "model/AddLocalNodesRequest.h"
 #include "model/AddLocalNodesResult.h"
 #include "model/AddNodesRequest.h"
@@ -100,6 +102,8 @@
 #include "model/DescribeNFSClientStatusResult.h"
 #include "model/DescribePriceRequest.h"
 #include "model/DescribePriceResult.h"
+#include "model/EcdDeleteDesktopsRequest.h"
+#include "model/EcdDeleteDesktopsResult.h"
 #include "model/EditJobTemplateRequest.h"
 #include "model/EditJobTemplateResult.h"
 #include "model/GetAccountingReportRequest.h"
@@ -272,6 +276,9 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::AddContainerAppResult> AddContainerAppOutcome;
 			typedef std::future<AddContainerAppOutcome> AddContainerAppOutcomeCallable;
 			typedef std::function<void(const EHPCClient*, const Model::AddContainerAppRequest&, const AddContainerAppOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> AddContainerAppAsyncHandler;
+			typedef Outcome<Error, Model::AddExistedNodesResult> AddExistedNodesOutcome;
+			typedef std::future<AddExistedNodesOutcome> AddExistedNodesOutcomeCallable;
+			typedef std::function<void(const EHPCClient*, const Model::AddExistedNodesRequest&, const AddExistedNodesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> AddExistedNodesAsyncHandler;
 			typedef Outcome<Error, Model::AddLocalNodesResult> AddLocalNodesOutcome;
 			typedef std::future<AddLocalNodesOutcome> AddLocalNodesOutcomeCallable;
 			typedef std::function<void(const EHPCClient*, const Model::AddLocalNodesRequest&, const AddLocalNodesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> AddLocalNodesAsyncHandler;
@@ -386,6 +393,9 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::DescribePriceResult> DescribePriceOutcome;
 			typedef std::future<DescribePriceOutcome> DescribePriceOutcomeCallable;
 			typedef std::function<void(const EHPCClient*, const Model::DescribePriceRequest&, const DescribePriceOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribePriceAsyncHandler;
+			typedef Outcome<Error, Model::EcdDeleteDesktopsResult> EcdDeleteDesktopsOutcome;
+			typedef std::future<EcdDeleteDesktopsOutcome> EcdDeleteDesktopsOutcomeCallable;
+			typedef std::function<void(const EHPCClient*, const Model::EcdDeleteDesktopsRequest&, const EcdDeleteDesktopsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> EcdDeleteDesktopsAsyncHandler;
 			typedef Outcome<Error, Model::EditJobTemplateResult> EditJobTemplateOutcome;
 			typedef std::future<EditJobTemplateOutcome> EditJobTemplateOutcomeCallable;
 			typedef std::function<void(const EHPCClient*, const Model::EditJobTemplateRequest&, const EditJobTemplateOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> EditJobTemplateAsyncHandler;
@@ -634,6 +644,9 @@ namespace AlibabaCloud
 			AddContainerAppOutcome addContainerApp(const Model::AddContainerAppRequest &request)const;
 			void addContainerAppAsync(const Model::AddContainerAppRequest& request, const AddContainerAppAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			AddContainerAppOutcomeCallable addContainerAppCallable(const Model::AddContainerAppRequest& request) const;
+			AddExistedNodesOutcome addExistedNodes(const Model::AddExistedNodesRequest &request)const;
+			void addExistedNodesAsync(const Model::AddExistedNodesRequest& request, const AddExistedNodesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			AddExistedNodesOutcomeCallable addExistedNodesCallable(const Model::AddExistedNodesRequest& request) const;
 			AddLocalNodesOutcome addLocalNodes(const Model::AddLocalNodesRequest &request)const;
 			void addLocalNodesAsync(const Model::AddLocalNodesRequest& request, const AddLocalNodesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			AddLocalNodesOutcomeCallable addLocalNodesCallable(const Model::AddLocalNodesRequest& request) const;
@@ -748,6 +761,9 @@ namespace AlibabaCloud
 			DescribePriceOutcome describePrice(const Model::DescribePriceRequest &request)const;
 			void describePriceAsync(const Model::DescribePriceRequest& request, const DescribePriceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			DescribePriceOutcomeCallable describePriceCallable(const Model::DescribePriceRequest& request) const;
+			EcdDeleteDesktopsOutcome ecdDeleteDesktops(const Model::EcdDeleteDesktopsRequest &request)const;
+			void ecdDeleteDesktopsAsync(const Model::EcdDeleteDesktopsRequest& request, const EcdDeleteDesktopsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			EcdDeleteDesktopsOutcomeCallable ecdDeleteDesktopsCallable(const Model::EcdDeleteDesktopsRequest& request) const;
 			EditJobTemplateOutcome editJobTemplate(const Model::EditJobTemplateRequest &request)const;
 			void editJobTemplateAsync(const Model::EditJobTemplateRequest& request, const EditJobTemplateAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			EditJobTemplateOutcomeCallable editJobTemplateCallable(const Model::EditJobTemplateRequest& request) const;

ehpc/include/alibabacloud/ehpc/model/AddExistedNodesRequest.h

@@ -0,0 +1,71 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_EHPC_MODEL_ADDEXISTEDNODESREQUEST_H_
+#define ALIBABACLOUD_EHPC_MODEL_ADDEXISTEDNODESREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/ehpc/EHPCExport.h>
+
+namespace AlibabaCloud
+{
+	namespace EHPC
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_EHPC_EXPORT AddExistedNodesRequest : public RpcServiceRequest
+			{
+			public:
+				struct Instance
+				{
+					std::string id;
+				};
+
+			public:
+				AddExistedNodesRequest();
+				~AddExistedNodesRequest();
+
+				std::string getImageId()const;
+				void setImageId(const std::string& imageId);
+				std::vector<Instance> getInstance()const;
+				void setInstance(const std::vector<Instance>& instance);
+				std::string getClientToken()const;
+				void setClientToken(const std::string& clientToken);
+				std::string getClusterId()const;
+				void setClusterId(const std::string& clusterId);
+				std::string getJobQueue()const;
+				void setJobQueue(const std::string& jobQueue);
+				std::string getAccessKeyId()const;
+				void setAccessKeyId(const std::string& accessKeyId);
+				std::string getImageOwnerAlias()const;
+				void setImageOwnerAlias(const std::string& imageOwnerAlias);
+
+            private:
+				std::string imageId_;
+				std::vector<Instance> instance_;
+				std::string clientToken_;
+				std::string clusterId_;
+				std::string jobQueue_;
+				std::string accessKeyId_;
+				std::string imageOwnerAlias_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_EHPC_MODEL_ADDEXISTEDNODESREQUEST_H_

ehpc/include/alibabacloud/ehpc/model/AddExistedNodesResult.h

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

ehpc/include/alibabacloud/ehpc/model/AddNodesRequest.h

@@ -53,6 +53,8 @@ namespace AlibabaCloud
 				void setImageOwnerAlias(const std::string& imageOwnerAlias);
 				std::string getSystemDiskType()const;
 				void setSystemDiskType(const std::string& systemDiskType);
+				int getMinCount()const;
+				void setMinCount(int minCount);
 				int getSystemDiskSize()const;
 				void setSystemDiskSize(int systemDiskSize);
 				std::string getInstanceType()const;
@@ -102,6 +104,7 @@ namespace AlibabaCloud
 				std::string accessKeyId_;
 				std::string imageOwnerAlias_;
 				std::string systemDiskType_;
+				int minCount_;
 				int systemDiskSize_;
 				std::string instanceType_;
 				std::string hostNamePrefix_;

ehpc/include/alibabacloud/ehpc/model/CreateClusterRequest.h

@@ -147,6 +147,8 @@ namespace AlibabaCloud
 				void setClientVersion(const std::string& clientVersion);
 				std::string getOsTag()const;
 				void setOsTag(const std::string& osTag);
+				bool getIsComputeEss()const;
+				void setIsComputeEss(bool isComputeEss);
 				std::vector<Application> getApplication()const;
 				void setApplication(const std::vector<Application>& application);
 				std::string getEcsChargeType()const;
@@ -208,6 +210,7 @@ namespace AlibabaCloud
 				std::string volumeProtocol_;
 				std::string clientVersion_;
 				std::string osTag_;
+				bool isComputeEss_;
 				std::vector<Application> application_;
 				std::string ecsChargeType_;
 				std::string inputFileUrl_;

ehpc/include/alibabacloud/ehpc/model/CreateHybridClusterRequest.h

@@ -55,6 +55,8 @@ namespace AlibabaCloud
 
 				std::string getKeyPairName()const;
 				void setKeyPairName(const std::string& keyPairName);
+				bool getMultiOs()const;
+				void setMultiOs(bool multiOs);
 				std::string getSecurityGroupName()const;
 				void setSecurityGroupName(const std::string& securityGroupName);
 				std::string getOnPremiseVolumeRemotePath()const;
@@ -128,6 +130,7 @@ namespace AlibabaCloud
 
             private:
 				std::string keyPairName_;
+				bool multiOs_;
 				std::string securityGroupName_;
 				std::string onPremiseVolumeRemotePath_;
 				std::string imageOwnerAlias_;

ehpc/include/alibabacloud/ehpc/model/CreateJobTemplateRequest.h

@@ -37,6 +37,8 @@ namespace AlibabaCloud
 
 				std::string getStderrRedirectPath()const;
 				void setStderrRedirectPath(const std::string& stderrRedirectPath);
+				std::string getClockTime()const;
+				void setClockTime(const std::string& clockTime);
 				std::string getCommandLine()const;
 				void setCommandLine(const std::string& commandLine);
 				std::string getAccessKeyId()const;
@@ -45,6 +47,8 @@ namespace AlibabaCloud
 				void setArrayRequest(const std::string& arrayRequest);
 				std::string getPackagePath()const;
 				void setPackagePath(const std::string& packagePath);
+				std::string getMem()const;
+				void setMem(const std::string& mem);
 				std::string getStdoutRedirectPath()const;
 				void setStdoutRedirectPath(const std::string& stdoutRedirectPath);
 				std::string getVariables()const;
@@ -53,23 +57,40 @@ namespace AlibabaCloud
 				void setRunasUser(const std::string& runasUser);
 				bool getReRunable()const;
 				void setReRunable(bool reRunable);
+				int getThread()const;
+				void setThread(int thread);
 				int getPriority()const;
 				void setPriority(int priority);
+				int getGpu()const;
+				void setGpu(int gpu);
+				int getNode()const;
+				void setNode(int node);
+				int getTask()const;
+				void setTask(int task);
 				std::string getName()const;
 				void setName(const std::string& name);
+				std::string getQueue()const;
+				void setQueue(const std::string& queue);
 
             private:
 				std::string stderrRedirectPath_;
+				std::string clockTime_;
 				std::string commandLine_;
 				std::string accessKeyId_;
 				std::string arrayRequest_;
 				std::string packagePath_;
+				std::string mem_;
 				std::string stdoutRedirectPath_;
 				std::string variables_;
 				std::string runasUser_;
 				bool reRunable_;
+				int thread_;
 				int priority_;
+				int gpu_;
+				int node_;
+				int task_;
 				std::string name_;
+				std::string queue_;
 
 			};
 		}

ehpc/include/alibabacloud/ehpc/model/DescribePriceRequest.h

@@ -38,6 +38,7 @@ namespace AlibabaCloud
 					std::string nodeType;
 					std::string systemDiskCategory;
 					std::string internetChargeType;
+					std::string systemDiskPerformanceLevel;
 					int systemDiskSize;
 					int internetMaxBandWidthOut;
 					std::string instanceType;

ehpc/include/alibabacloud/ehpc/model/EcdDeleteDesktopsRequest.h

@@ -0,0 +1,51 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_EHPC_MODEL_ECDDELETEDESKTOPSREQUEST_H_
+#define ALIBABACLOUD_EHPC_MODEL_ECDDELETEDESKTOPSREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/ehpc/EHPCExport.h>
+
+namespace AlibabaCloud
+{
+	namespace EHPC
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_EHPC_EXPORT EcdDeleteDesktopsRequest : public RpcServiceRequest
+			{
+
+			public:
+				EcdDeleteDesktopsRequest();
+				~EcdDeleteDesktopsRequest();
+
+				std::string getAccessKeyId()const;
+				void setAccessKeyId(const std::string& accessKeyId);
+				std::vector<std::string> getDesktopId()const;
+				void setDesktopId(const std::vector<std::string>& desktopId);
+
+            private:
+				std::string accessKeyId_;
+				std::vector<std::string> desktopId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_EHPC_MODEL_ECDDELETEDESKTOPSREQUEST_H_

ehpc/include/alibabacloud/ehpc/model/EcdDeleteDesktopsResult.h

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

ehpc/include/alibabacloud/ehpc/model/EditJobTemplateRequest.h

@@ -37,6 +37,8 @@ namespace AlibabaCloud
 
 				std::string getStderrRedirectPath()const;
 				void setStderrRedirectPath(const std::string& stderrRedirectPath);
+				std::string getClockTime()const;
+				void setClockTime(const std::string& clockTime);
 				std::string getCommandLine()const;
 				void setCommandLine(const std::string& commandLine);
 				std::string getAccessKeyId()const;
@@ -45,6 +47,8 @@ namespace AlibabaCloud
 				void setArrayRequest(const std::string& arrayRequest);
 				std::string getPackagePath()const;
 				void setPackagePath(const std::string& packagePath);
+				std::string getMem()const;
+				void setMem(const std::string& mem);
 				std::string getStdoutRedirectPath()const;
 				void setStdoutRedirectPath(const std::string& stdoutRedirectPath);
 				std::string getVariables()const;
@@ -53,26 +57,43 @@ namespace AlibabaCloud
 				void setRunasUser(const std::string& runasUser);
 				bool getReRunable()const;
 				void setReRunable(bool reRunable);
+				int getThread()const;
+				void setThread(int thread);
 				std::string getTemplateId()const;
 				void setTemplateId(const std::string& templateId);
 				int getPriority()const;
 				void setPriority(int priority);
+				int getGpu()const;
+				void setGpu(int gpu);
+				int getNode()const;
+				void setNode(int node);
+				int getTask()const;
+				void setTask(int task);
 				std::string getName()const;
 				void setName(const std::string& name);
+				std::string getQueue()const;
+				void setQueue(const std::string& queue);
 
             private:
 				std::string stderrRedirectPath_;
+				std::string clockTime_;
 				std::string commandLine_;
 				std::string accessKeyId_;
 				std::string arrayRequest_;
 				std::string packagePath_;
+				std::string mem_;
 				std::string stdoutRedirectPath_;
 				std::string variables_;
 				std::string runasUser_;
 				bool reRunable_;
+				int thread_;
 				std::string templateId_;
 				int priority_;
+				int gpu_;
+				int node_;
+				int task_;
 				std::string name_;
+				std::string queue_;
 
 			};
 		}

ehpc/include/alibabacloud/ehpc/model/ListClustersMetaResult.h

@@ -36,6 +36,7 @@ namespace AlibabaCloud
 				{
 					std::string status;
 					std::string description;
+					bool isComputeEss;
 					std::string vpcId;
 					std::string deployMode;
 					std::string osTag;

ehpc/include/alibabacloud/ehpc/model/ListClustersResult.h

@@ -78,6 +78,7 @@ namespace AlibabaCloud
 					std::string loginNodes;
 					Computes computes;
 					std::string status;
+					bool isComputeEss;
 					std::string zoneId;
 					std::string vSwitchId;
 					std::string createTime;

ehpc/include/alibabacloud/ehpc/model/ListCustomImagesRequest.h

@@ -35,6 +35,8 @@ namespace AlibabaCloud
 				ListCustomImagesRequest();
 				~ListCustomImagesRequest();
 
+				std::string getClusterId()const;
+				void setClusterId(const std::string& clusterId);
 				std::string getAccessKeyId()const;
 				void setAccessKeyId(const std::string& accessKeyId);
 				std::string getImageOwnerAlias()const;
@@ -45,6 +47,7 @@ namespace AlibabaCloud
 				void setInstanceType(const std::string& instanceType);
 
             private:
+				std::string clusterId_;
 				std::string accessKeyId_;
 				std::string imageOwnerAlias_;
 				std::string baseOsTag_;

ehpc/include/alibabacloud/ehpc/model/ListJobTemplatesResult.h

@@ -34,17 +34,24 @@ namespace AlibabaCloud
 			public:
 				struct JobTemplates
 				{
+					int task;
+					int priority;
+					std::string stderrRedirectPath;
+					int node;
+					std::string clockTime;
+					std::string runasUser;
+					int gpu;
+					std::string name;
+					int thread;
 					std::string variables;
 					bool reRunable;
 					std::string commandLine;
-					int priority;
-					std::string stderrRedirectPath;
+					std::string mem;
 					std::string stdoutRedirectPath;
 					std::string id;
 					std::string arrayRequest;
-					std::string runasUser;
+					std::string queue;
 					std::string packagePath;
-					std::string name;
 				};
 
 

ehpc/include/alibabacloud/ehpc/model/ListNodesRequest.h

@@ -37,35 +37,41 @@ namespace AlibabaCloud
 
 				std::string getRole()const;
 				void setRole(const std::string& role);
-				std::string getClusterId()const;
-				void setClusterId(const std::string& clusterId);
 				int getPageNumber()const;
 				void setPageNumber(int pageNumber);
 				std::string getAccessKeyId()const;
 				void setAccessKeyId(const std::string& accessKeyId);
+				std::string getHostName()const;
+				void setHostName(const std::string& hostName);
+				int getPageSize()const;
+				void setPageSize(int pageSize);
+				std::string getHostNamePrefix()const;
+				void setHostNamePrefix(const std::string& hostNamePrefix);
+				std::string getClusterId()const;
+				void setClusterId(const std::string& clusterId);
+				std::string getHostNameSuffix()const;
+				void setHostNameSuffix(const std::string& hostNameSuffix);
 				std::string getFilter()const;
 				void setFilter(const std::string& filter);
 				std::string getPrivateIpAddress()const;
 				void setPrivateIpAddress(const std::string& privateIpAddress);
 				std::string getSequence()const;
 				void setSequence(const std::string& sequence);
-				std::string getHostName()const;
-				void setHostName(const std::string& hostName);
-				int getPageSize()const;
-				void setPageSize(int pageSize);
 				std::string getSortBy()const;
 				void setSortBy(const std::string& sortBy);
 
             private:
 				std::string role_;
-				std::string clusterId_;
 				int pageNumber_;
 				std::string accessKeyId_;
+				std::string hostName_;
+				int pageSize_;
+				std::string hostNamePrefix_;
+				std::string clusterId_;
+				std::string hostNameSuffix_;
 				std::string filter_;
 				std::string privateIpAddress_;
 				std::string sequence_;
-				std::string hostName_;
-				int pageSize_;
 				std::string sortBy_;
 
 			};

ehpc/include/alibabacloud/ehpc/model/ListQueuesResult.h

@@ -34,10 +34,21 @@ namespace AlibabaCloud
 			public:
 				struct QueueInfo
 				{
+					struct Instance
+					{
+						float spotPriceLimit;
+						std::string instanceType;
+					};
+					std::string hostNameSuffix;
 					std::string type;
+					std::vector<QueueInfo::Instance> spotInstanceTypes;
 					std::string resourceGroupId;
+					bool enableAutoGrow;
+					std::string imageId;
+					std::string hostNamePrefix;
 					std::string queueName;
-					std::string computeInstanceType;
+					std::string spotStrategy;
+					std::vector<std::string> computeInstanceType;
 				};
 
 

ehpc/src/EHPCClient.cc

@@ -87,6 +87,42 @@ EHPCClient::AddContainerAppOutcomeCallable EHPCClient::addContainerAppCallable(c
 	return task->get_future();
 }
 
+EHPCClient::AddExistedNodesOutcome EHPCClient::addExistedNodes(const AddExistedNodesRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return AddExistedNodesOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return AddExistedNodesOutcome(AddExistedNodesResult(outcome.result()));
+	else
+		return AddExistedNodesOutcome(outcome.error());
+}
+
+void EHPCClient::addExistedNodesAsync(const AddExistedNodesRequest& request, const AddExistedNodesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, addExistedNodes(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+EHPCClient::AddExistedNodesOutcomeCallable EHPCClient::addExistedNodesCallable(const AddExistedNodesRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<AddExistedNodesOutcome()>>(
+			[this, request]()
+			{
+			return this->addExistedNodes(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 EHPCClient::AddLocalNodesOutcome EHPCClient::addLocalNodes(const AddLocalNodesRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -1455,6 +1491,42 @@ EHPCClient::DescribePriceOutcomeCallable EHPCClient::describePriceCallable(const
 	return task->get_future();
 }
 
+EHPCClient::EcdDeleteDesktopsOutcome EHPCClient::ecdDeleteDesktops(const EcdDeleteDesktopsRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return EcdDeleteDesktopsOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return EcdDeleteDesktopsOutcome(EcdDeleteDesktopsResult(outcome.result()));
+	else
+		return EcdDeleteDesktopsOutcome(outcome.error());
+}
+
+void EHPCClient::ecdDeleteDesktopsAsync(const EcdDeleteDesktopsRequest& request, const EcdDeleteDesktopsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, ecdDeleteDesktops(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+EHPCClient::EcdDeleteDesktopsOutcomeCallable EHPCClient::ecdDeleteDesktopsCallable(const EcdDeleteDesktopsRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<EcdDeleteDesktopsOutcome()>>(
+			[this, request]()
+			{
+			return this->ecdDeleteDesktops(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 EHPCClient::EditJobTemplateOutcome EHPCClient::editJobTemplate(const EditJobTemplateRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();

ehpc/src/model/AddExistedNodesRequest.cc

@@ -0,0 +1,110 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/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("ImageId", imageId);
+}
+
+std::vector<AddExistedNodesRequest::Instance> AddExistedNodesRequest::getInstance()const
+{
+	return instance_;
+}
+
+void AddExistedNodesRequest::setInstance(const std::vector<Instance>& instance)
+{
+	instance_ = instance;
+	for(int dep1 = 0; dep1!= instance.size(); dep1++) {
+		auto instanceObj = instance.at(dep1);
+		std::string instanceObjStr = "Instance." + std::to_string(dep1 + 1);
+		setParameter(instanceObjStr + ".Id", instanceObj.id);
+	}
+}
+
+std::string AddExistedNodesRequest::getClientToken()const
+{
+	return clientToken_;
+}
+
+void AddExistedNodesRequest::setClientToken(const std::string& clientToken)
+{
+	clientToken_ = clientToken;
+	setParameter("ClientToken", clientToken);
+}
+
+std::string AddExistedNodesRequest::getClusterId()const
+{
+	return clusterId_;
+}
+
+void AddExistedNodesRequest::setClusterId(const std::string& clusterId)
+{
+	clusterId_ = clusterId;
+	setParameter("ClusterId", clusterId);
+}
+
+std::string AddExistedNodesRequest::getJobQueue()const
+{
+	return jobQueue_;
+}
+
+void AddExistedNodesRequest::setJobQueue(const std::string& jobQueue)
+{
+	jobQueue_ = jobQueue;
+	setParameter("JobQueue", jobQueue);
+}
+
+std::string AddExistedNodesRequest::getAccessKeyId()const
+{
+	return accessKeyId_;
+}
+
+void AddExistedNodesRequest::setAccessKeyId(const std::string& accessKeyId)
+{
+	accessKeyId_ = accessKeyId;
+	setParameter("AccessKeyId", accessKeyId);
+}
+
+std::string AddExistedNodesRequest::getImageOwnerAlias()const
+{
+	return imageOwnerAlias_;
+}
+
+void AddExistedNodesRequest::setImageOwnerAlias(const std::string& imageOwnerAlias)
+{
+	imageOwnerAlias_ = imageOwnerAlias;
+	setParameter("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/AddNodesRequest.cc

@@ -126,6 +126,17 @@ void AddNodesRequest::setSystemDiskType(const std::string& systemDiskType)
 	setParameter("SystemDiskType", systemDiskType);
 }
 
+int AddNodesRequest::getMinCount()const
+{
+	return minCount_;
+}
+
+void AddNodesRequest::setMinCount(int minCount)
+{
+	minCount_ = minCount;
+	setParameter("MinCount", std::to_string(minCount));
+}
+
 int AddNodesRequest::getSystemDiskSize()const
 {
 	return systemDiskSize_;

ehpc/src/model/CreateClusterRequest.cc

@@ -521,6 +521,17 @@ void CreateClusterRequest::setOsTag(const std::string& osTag)
 	setParameter("OsTag", osTag);
 }
 
+bool CreateClusterRequest::getIsComputeEss()const
+{
+	return isComputeEss_;
+}
+
+void CreateClusterRequest::setIsComputeEss(bool isComputeEss)
+{
+	isComputeEss_ = isComputeEss;
+	setParameter("IsComputeEss", isComputeEss ? "true" : "false");
+}
+
 std::vector<CreateClusterRequest::Application> CreateClusterRequest::getApplication()const
 {
 	return application_;

ehpc/src/model/CreateHybridClusterRequest.cc

@@ -38,6 +38,17 @@ void CreateHybridClusterRequest::setKeyPairName(const std::string& keyPairName)
 	setParameter("KeyPairName", keyPairName);
 }
 
+bool CreateHybridClusterRequest::getMultiOs()const
+{
+	return multiOs_;
+}
+
+void CreateHybridClusterRequest::setMultiOs(bool multiOs)
+{
+	multiOs_ = multiOs;
+	setParameter("MultiOs", multiOs ? "true" : "false");
+}
+
 std::string CreateHybridClusterRequest::getSecurityGroupName()const
 {
 	return securityGroupName_;

ehpc/src/model/CreateJobTemplateRequest.cc

@@ -38,6 +38,17 @@ void CreateJobTemplateRequest::setStderrRedirectPath(const std::string& stderrRe
 	setParameter("StderrRedirectPath", stderrRedirectPath);
 }
 
+std::string CreateJobTemplateRequest::getClockTime()const
+{
+	return clockTime_;
+}
+
+void CreateJobTemplateRequest::setClockTime(const std::string& clockTime)
+{
+	clockTime_ = clockTime;
+	setParameter("ClockTime", clockTime);
+}
+
 std::string CreateJobTemplateRequest::getCommandLine()const
 {
 	return commandLine_;
@@ -82,6 +93,17 @@ void CreateJobTemplateRequest::setPackagePath(const std::string& packagePath)
 	setParameter("PackagePath", packagePath);
 }
 
+std::string CreateJobTemplateRequest::getMem()const
+{
+	return mem_;
+}
+
+void CreateJobTemplateRequest::setMem(const std::string& mem)
+{
+	mem_ = mem;
+	setParameter("Mem", mem);
+}
+
 std::string CreateJobTemplateRequest::getStdoutRedirectPath()const
 {
 	return stdoutRedirectPath_;
@@ -126,6 +148,17 @@ void CreateJobTemplateRequest::setReRunable(bool reRunable)
 	setParameter("ReRunable", reRunable ? "true" : "false");
 }
 
+int CreateJobTemplateRequest::getThread()const
+{
+	return thread_;
+}
+
+void CreateJobTemplateRequest::setThread(int thread)
+{
+	thread_ = thread;
+	setParameter("Thread", std::to_string(thread));
+}
+
 int CreateJobTemplateRequest::getPriority()const
 {
 	return priority_;
@@ -137,6 +170,39 @@ void CreateJobTemplateRequest::setPriority(int priority)
 	setParameter("Priority", std::to_string(priority));
 }
 
+int CreateJobTemplateRequest::getGpu()const
+{
+	return gpu_;
+}
+
+void CreateJobTemplateRequest::setGpu(int gpu)
+{
+	gpu_ = gpu;
+	setParameter("Gpu", std::to_string(gpu));
+}
+
+int CreateJobTemplateRequest::getNode()const
+{
+	return node_;
+}
+
+void CreateJobTemplateRequest::setNode(int node)
+{
+	node_ = node;
+	setParameter("Node", std::to_string(node));
+}
+
+int CreateJobTemplateRequest::getTask()const
+{
+	return task_;
+}
+
+void CreateJobTemplateRequest::setTask(int task)
+{
+	task_ = task;
+	setParameter("Task", std::to_string(task));
+}
+
 std::string CreateJobTemplateRequest::getName()const
 {
 	return name_;
@@ -148,3 +214,14 @@ void CreateJobTemplateRequest::setName(const std::string& name)
 	setParameter("Name", name);
 }
 
+std::string CreateJobTemplateRequest::getQueue()const
+{
+	return queue_;
+}
+
+void CreateJobTemplateRequest::setQueue(const std::string& queue)
+{
+	queue_ = queue;
+	setParameter("Queue", queue);
+}
+

ehpc/src/model/DescribePriceRequest.cc

@@ -43,6 +43,7 @@ void DescribePriceRequest::setCommodities(const std::vector<Commodities>& commod
 		setParameter(commoditiesObjStr + ".NodeType", commoditiesObj.nodeType);
 		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);

ehpc/src/model/EcdDeleteDesktopsRequest.cc

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

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

ehpc/src/model/EditJobTemplateRequest.cc

@@ -38,6 +38,17 @@ void EditJobTemplateRequest::setStderrRedirectPath(const std::string& stderrRedi
 	setParameter("StderrRedirectPath", stderrRedirectPath);
 }
 
+std::string EditJobTemplateRequest::getClockTime()const
+{
+	return clockTime_;
+}
+
+void EditJobTemplateRequest::setClockTime(const std::string& clockTime)
+{
+	clockTime_ = clockTime;
+	setParameter("ClockTime", clockTime);
+}
+
 std::string EditJobTemplateRequest::getCommandLine()const
 {
 	return commandLine_;
@@ -82,6 +93,17 @@ void EditJobTemplateRequest::setPackagePath(const std::string& packagePath)
 	setParameter("PackagePath", packagePath);
 }
 
+std::string EditJobTemplateRequest::getMem()const
+{
+	return mem_;
+}
+
+void EditJobTemplateRequest::setMem(const std::string& mem)
+{
+	mem_ = mem;
+	setParameter("Mem", mem);
+}
+
 std::string EditJobTemplateRequest::getStdoutRedirectPath()const
 {
 	return stdoutRedirectPath_;
@@ -126,6 +148,17 @@ void EditJobTemplateRequest::setReRunable(bool reRunable)
 	setParameter("ReRunable", reRunable ? "true" : "false");
 }
 
+int EditJobTemplateRequest::getThread()const
+{
+	return thread_;
+}
+
+void EditJobTemplateRequest::setThread(int thread)
+{
+	thread_ = thread;
+	setParameter("Thread", std::to_string(thread));
+}
+
 std::string EditJobTemplateRequest::getTemplateId()const
 {
 	return templateId_;
@@ -148,6 +181,39 @@ void EditJobTemplateRequest::setPriority(int priority)
 	setParameter("Priority", std::to_string(priority));
 }
 
+int EditJobTemplateRequest::getGpu()const
+{
+	return gpu_;
+}
+
+void EditJobTemplateRequest::setGpu(int gpu)
+{
+	gpu_ = gpu;
+	setParameter("Gpu", std::to_string(gpu));
+}
+
+int EditJobTemplateRequest::getNode()const
+{
+	return node_;
+}
+
+void EditJobTemplateRequest::setNode(int node)
+{
+	node_ = node;
+	setParameter("Node", std::to_string(node));
+}
+
+int EditJobTemplateRequest::getTask()const
+{
+	return task_;
+}
+
+void EditJobTemplateRequest::setTask(int task)
+{
+	task_ = task;
+	setParameter("Task", std::to_string(task));
+}
+
 std::string EditJobTemplateRequest::getName()const
 {
 	return name_;
@@ -159,3 +225,14 @@ void EditJobTemplateRequest::setName(const std::string& name)
 	setParameter("Name", name);
 }
 
+std::string EditJobTemplateRequest::getQueue()const
+{
+	return queue_;
+}
+
+void EditJobTemplateRequest::setQueue(const std::string& queue)
+{
+	queue_ = queue;
+	setParameter("Queue", queue);
+}
+

ehpc/src/model/ListClustersMetaResult.cc

@@ -65,6 +65,8 @@ void ListClustersMetaResult::parse(const std::string &payload)
 			clustersObject.vpcId = valueClustersClusterInfoSimple["VpcId"].asString();
 		if(!valueClustersClusterInfoSimple["DeployMode"].isNull())
 			clustersObject.deployMode = valueClustersClusterInfoSimple["DeployMode"].asString();
+		if(!valueClustersClusterInfoSimple["IsComputeEss"].isNull())
+			clustersObject.isComputeEss = valueClustersClusterInfoSimple["IsComputeEss"].asString() == "true";
 		clusters_.push_back(clustersObject);
 	}
 	if(!value["TotalCount"].isNull())

ehpc/src/model/ListClustersResult.cc

@@ -97,6 +97,8 @@ void ListClustersResult::parse(const std::string &payload)
 			clustersObject.computeSpotPriceLimit = std::stof(valueClustersClusterInfoSimple["ComputeSpotPriceLimit"].asString());
 		if(!valueClustersClusterInfoSimple["ClientVersion"].isNull())
 			clustersObject.clientVersion = valueClustersClusterInfoSimple["ClientVersion"].asString();
+		if(!valueClustersClusterInfoSimple["IsComputeEss"].isNull())
+			clustersObject.isComputeEss = valueClustersClusterInfoSimple["IsComputeEss"].asString() == "true";
 		auto managersNode = value["Managers"];
 		if(!managersNode["Total"].isNull())
 			clustersObject.managers.total = std::stoi(managersNode["Total"].asString());

ehpc/src/model/ListCustomImagesRequest.cc

@@ -27,6 +27,17 @@ ListCustomImagesRequest::ListCustomImagesRequest() :
 ListCustomImagesRequest::~ListCustomImagesRequest()
 {}
 
+std::string ListCustomImagesRequest::getClusterId()const
+{
+	return clusterId_;
+}
+
+void ListCustomImagesRequest::setClusterId(const std::string& clusterId)
+{
+	clusterId_ = clusterId;
+	setParameter("ClusterId", clusterId);
+}
+
 std::string ListCustomImagesRequest::getAccessKeyId()const
 {
 	return accessKeyId_;

ehpc/src/model/ListJobTemplatesResult.cc

@@ -65,6 +65,20 @@ void ListJobTemplatesResult::parse(const std::string &payload)
 			templatesObject.arrayRequest = valueTemplatesJobTemplates["ArrayRequest"].asString();
 		if(!valueTemplatesJobTemplates["Variables"].isNull())
 			templatesObject.variables = valueTemplatesJobTemplates["Variables"].asString();
+		if(!valueTemplatesJobTemplates["Queue"].isNull())
+			templatesObject.queue = valueTemplatesJobTemplates["Queue"].asString();
+		if(!valueTemplatesJobTemplates["ClockTime"].isNull())
+			templatesObject.clockTime = valueTemplatesJobTemplates["ClockTime"].asString();
+		if(!valueTemplatesJobTemplates["Node"].isNull())
+			templatesObject.node = std::stoi(valueTemplatesJobTemplates["Node"].asString());
+		if(!valueTemplatesJobTemplates["Task"].isNull())
+			templatesObject.task = std::stoi(valueTemplatesJobTemplates["Task"].asString());
+		if(!valueTemplatesJobTemplates["Thread"].isNull())
+			templatesObject.thread = std::stoi(valueTemplatesJobTemplates["Thread"].asString());
+		if(!valueTemplatesJobTemplates["Mem"].isNull())
+			templatesObject.mem = valueTemplatesJobTemplates["Mem"].asString();
+		if(!valueTemplatesJobTemplates["Gpu"].isNull())
+			templatesObject.gpu = std::stoi(valueTemplatesJobTemplates["Gpu"].asString());
 		templates_.push_back(templatesObject);
 	}
 	if(!value["TotalCount"].isNull())

ehpc/src/model/ListNodesRequest.cc

@@ -38,17 +38,6 @@ void ListNodesRequest::setRole(const std::string& role)
 	setParameter("Role", role);
 }
 
-std::string ListNodesRequest::getClusterId()const
-{
-	return clusterId_;
-}
-
-void ListNodesRequest::setClusterId(const std::string& clusterId)
-{
-	clusterId_ = clusterId;
-	setParameter("ClusterId", clusterId);
-}
-
 int ListNodesRequest::getPageNumber()const
 {
 	return pageNumber_;
@@ -71,6 +60,61 @@ void ListNodesRequest::setAccessKeyId(const std::string& accessKeyId)
 	setParameter("AccessKeyId", accessKeyId);
 }
 
+std::string ListNodesRequest::getHostName()const
+{
+	return hostName_;
+}
+
+void ListNodesRequest::setHostName(const std::string& hostName)
+{
+	hostName_ = hostName;
+	setParameter("HostName", hostName);
+}
+
+int ListNodesRequest::getPageSize()const
+{
+	return pageSize_;
+}
+
+void ListNodesRequest::setPageSize(int pageSize)
+{
+	pageSize_ = pageSize;
+	setParameter("PageSize", std::to_string(pageSize));
+}
+
+std::string ListNodesRequest::getHostNamePrefix()const
+{
+	return hostNamePrefix_;
+}
+
+void ListNodesRequest::setHostNamePrefix(const std::string& hostNamePrefix)
+{
+	hostNamePrefix_ = hostNamePrefix;
+	setParameter("HostNamePrefix", hostNamePrefix);
+}
+
+std::string ListNodesRequest::getClusterId()const
+{
+	return clusterId_;
+}
+
+void ListNodesRequest::setClusterId(const std::string& clusterId)
+{
+	clusterId_ = clusterId;
+	setParameter("ClusterId", clusterId);
+}
+
+std::string ListNodesRequest::getHostNameSuffix()const
+{
+	return hostNameSuffix_;
+}
+
+void ListNodesRequest::setHostNameSuffix(const std::string& hostNameSuffix)
+{
+	hostNameSuffix_ = hostNameSuffix;
+	setParameter("HostNameSuffix", hostNameSuffix);
+}
+
 std::string ListNodesRequest::getFilter()const
 {
 	return filter_;
@@ -104,28 +148,6 @@ void ListNodesRequest::setSequence(const std::string& sequence)
 	setParameter("Sequence", sequence);
 }
 
-std::string ListNodesRequest::getHostName()const
-{
-	return hostName_;
-}
-
-void ListNodesRequest::setHostName(const std::string& hostName)
-{
-	hostName_ = hostName;
-	setParameter("HostName", hostName);
-}
-
-int ListNodesRequest::getPageSize()const
-{
-	return pageSize_;
-}
-
-void ListNodesRequest::setPageSize(int pageSize)
-{
-	pageSize_ = pageSize;
-	setParameter("PageSize", std::to_string(pageSize));
-}
-
 std::string ListNodesRequest::getSortBy()const
 {
 	return sortBy_;

ehpc/src/model/ListQueuesResult.cc

@@ -49,8 +49,29 @@ void ListQueuesResult::parse(const std::string &payload)
 			queuesObject.type = valueQueuesQueueInfo["Type"].asString();
 		if(!valueQueuesQueueInfo["ResourceGroupId"].isNull())
 			queuesObject.resourceGroupId = valueQueuesQueueInfo["ResourceGroupId"].asString();
-		if(!valueQueuesQueueInfo["ComputeInstanceType"].isNull())
-			queuesObject.computeInstanceType = valueQueuesQueueInfo["ComputeInstanceType"].asString();
+		if(!valueQueuesQueueInfo["HostNamePrefix"].isNull())
+			queuesObject.hostNamePrefix = valueQueuesQueueInfo["HostNamePrefix"].asString();
+		if(!valueQueuesQueueInfo["HostNameSuffix"].isNull())
+			queuesObject.hostNameSuffix = valueQueuesQueueInfo["HostNameSuffix"].asString();
+		if(!valueQueuesQueueInfo["SpotStrategy"].isNull())
+			queuesObject.spotStrategy = valueQueuesQueueInfo["SpotStrategy"].asString();
+		if(!valueQueuesQueueInfo["ImageId"].isNull())
+			queuesObject.imageId = valueQueuesQueueInfo["ImageId"].asString();
+		if(!valueQueuesQueueInfo["EnableAutoGrow"].isNull())
+			queuesObject.enableAutoGrow = valueQueuesQueueInfo["EnableAutoGrow"].asString() == "true";
+		auto allSpotInstanceTypesNode = valueQueuesQueueInfo["SpotInstanceTypes"]["Instance"];
+		for (auto valueQueuesQueueInfoSpotInstanceTypesInstance : allSpotInstanceTypesNode)
+		{
+			QueueInfo::Instance spotInstanceTypesObject;
+			if(!valueQueuesQueueInfoSpotInstanceTypesInstance["InstanceType"].isNull())
+				spotInstanceTypesObject.instanceType = valueQueuesQueueInfoSpotInstanceTypesInstance["InstanceType"].asString();
+			if(!valueQueuesQueueInfoSpotInstanceTypesInstance["SpotPriceLimit"].isNull())
+				spotInstanceTypesObject.spotPriceLimit = std::stof(valueQueuesQueueInfoSpotInstanceTypesInstance["SpotPriceLimit"].asString());
+			queuesObject.spotInstanceTypes.push_back(spotInstanceTypesObject);
+		}
+		auto allComputeInstanceType = value["ComputeInstanceType"]["InstanceType"];
+		for (auto value : allComputeInstanceType)
+			queuesObject.computeInstanceType.push_back(value.asString());
 		queues_.push_back(queuesObject);
 	}