Support Round and Interval for ApplyNodes API.

CHANGELOG

@@ -1,3 +1,6 @@
+2021-08-19 Version: 1.36.855
+- Support Round and Interval for ApplyNodes API.
+
 2021-08-19 Version: 1.36.854
 - Supported new features for outbound.
 

VERSION

@@ -1 +1 @@
-1.36.854
+1.36.855

ehpc/CMakeLists.txt

@@ -37,8 +37,6 @@ set(ehpc_public_header_model
 	include/alibabacloud/ehpc/model/AddUsersResult.h
 	include/alibabacloud/ehpc/model/ApplyNodesRequest.h
 	include/alibabacloud/ehpc/model/ApplyNodesResult.h
-	include/alibabacloud/ehpc/model/BindAccountToClusterUserRequest.h
-	include/alibabacloud/ehpc/model/BindAccountToClusterUserResult.h
 	include/alibabacloud/ehpc/model/CreateClusterRequest.h
 	include/alibabacloud/ehpc/model/CreateClusterResult.h
 	include/alibabacloud/ehpc/model/CreateGWSClusterRequest.h
@@ -123,6 +121,8 @@ set(ehpc_public_header_model
 	include/alibabacloud/ehpc/model/GetHybridClusterConfigResult.h
 	include/alibabacloud/ehpc/model/GetIfEcsTypeSupportHtConfigRequest.h
 	include/alibabacloud/ehpc/model/GetIfEcsTypeSupportHtConfigResult.h
+	include/alibabacloud/ehpc/model/GetSchedulerInfoRequest.h
+	include/alibabacloud/ehpc/model/GetSchedulerInfoResult.h
 	include/alibabacloud/ehpc/model/GetVisualServiceStatusRequest.h
 	include/alibabacloud/ehpc/model/GetVisualServiceStatusResult.h
 	include/alibabacloud/ehpc/model/GetWorkbenchTokenRequest.h
@@ -133,12 +133,8 @@ set(ehpc_public_header_model
 	include/alibabacloud/ehpc/model/InstallSoftwareResult.h
 	include/alibabacloud/ehpc/model/InvokeShellCommandRequest.h
 	include/alibabacloud/ehpc/model/InvokeShellCommandResult.h
-	include/alibabacloud/ehpc/model/ListAccountMappingRequest.h
-	include/alibabacloud/ehpc/model/ListAccountMappingResult.h
 	include/alibabacloud/ehpc/model/ListAvailableEcsTypesRequest.h
 	include/alibabacloud/ehpc/model/ListAvailableEcsTypesResult.h
-	include/alibabacloud/ehpc/model/ListAvailableFileSystemTypesRequest.h
-	include/alibabacloud/ehpc/model/ListAvailableFileSystemTypesResult.h
 	include/alibabacloud/ehpc/model/ListCloudMetricProfilingsRequest.h
 	include/alibabacloud/ehpc/model/ListCloudMetricProfilingsResult.h
 	include/alibabacloud/ehpc/model/ListClusterLogsRequest.h
@@ -229,10 +225,10 @@ set(ehpc_public_header_model
 	include/alibabacloud/ehpc/model/SetGWSInstanceNameResult.h
 	include/alibabacloud/ehpc/model/SetGWSInstanceUserRequest.h
 	include/alibabacloud/ehpc/model/SetGWSInstanceUserResult.h
-	include/alibabacloud/ehpc/model/SetJobUserRequest.h
-	include/alibabacloud/ehpc/model/SetJobUserResult.h
 	include/alibabacloud/ehpc/model/SetQueueRequest.h
 	include/alibabacloud/ehpc/model/SetQueueResult.h
+	include/alibabacloud/ehpc/model/SetSchedulerInfoRequest.h
+	include/alibabacloud/ehpc/model/SetSchedulerInfoResult.h
 	include/alibabacloud/ehpc/model/StartClusterRequest.h
 	include/alibabacloud/ehpc/model/StartClusterResult.h
 	include/alibabacloud/ehpc/model/StartGWSInstanceRequest.h
@@ -253,8 +249,6 @@ set(ehpc_public_header_model
 	include/alibabacloud/ehpc/model/StopVisualServiceResult.h
 	include/alibabacloud/ehpc/model/SubmitJobRequest.h
 	include/alibabacloud/ehpc/model/SubmitJobResult.h
-	include/alibabacloud/ehpc/model/UnbindAccountToClusterUserRequest.h
-	include/alibabacloud/ehpc/model/UnbindAccountToClusterUserResult.h
 	include/alibabacloud/ehpc/model/UninstallSoftwareRequest.h
 	include/alibabacloud/ehpc/model/UninstallSoftwareResult.h
 	include/alibabacloud/ehpc/model/UpdateClusterVolumesRequest.h
@@ -282,8 +276,6 @@ set(ehpc_src
 	src/model/AddUsersResult.cc
 	src/model/ApplyNodesRequest.cc
 	src/model/ApplyNodesResult.cc
-	src/model/BindAccountToClusterUserRequest.cc
-	src/model/BindAccountToClusterUserResult.cc
 	src/model/CreateClusterRequest.cc
 	src/model/CreateClusterResult.cc
 	src/model/CreateGWSClusterRequest.cc
@@ -368,6 +360,8 @@ set(ehpc_src
 	src/model/GetHybridClusterConfigResult.cc
 	src/model/GetIfEcsTypeSupportHtConfigRequest.cc
 	src/model/GetIfEcsTypeSupportHtConfigResult.cc
+	src/model/GetSchedulerInfoRequest.cc
+	src/model/GetSchedulerInfoResult.cc
 	src/model/GetVisualServiceStatusRequest.cc
 	src/model/GetVisualServiceStatusResult.cc
 	src/model/GetWorkbenchTokenRequest.cc
@@ -378,12 +372,8 @@ set(ehpc_src
 	src/model/InstallSoftwareResult.cc
 	src/model/InvokeShellCommandRequest.cc
 	src/model/InvokeShellCommandResult.cc
-	src/model/ListAccountMappingRequest.cc
-	src/model/ListAccountMappingResult.cc
 	src/model/ListAvailableEcsTypesRequest.cc
 	src/model/ListAvailableEcsTypesResult.cc
-	src/model/ListAvailableFileSystemTypesRequest.cc
-	src/model/ListAvailableFileSystemTypesResult.cc
 	src/model/ListCloudMetricProfilingsRequest.cc
 	src/model/ListCloudMetricProfilingsResult.cc
 	src/model/ListClusterLogsRequest.cc
@@ -474,10 +464,10 @@ set(ehpc_src
 	src/model/SetGWSInstanceNameResult.cc
 	src/model/SetGWSInstanceUserRequest.cc
 	src/model/SetGWSInstanceUserResult.cc
-	src/model/SetJobUserRequest.cc
-	src/model/SetJobUserResult.cc
 	src/model/SetQueueRequest.cc
 	src/model/SetQueueResult.cc
+	src/model/SetSchedulerInfoRequest.cc
+	src/model/SetSchedulerInfoResult.cc
 	src/model/StartClusterRequest.cc
 	src/model/StartClusterResult.cc
 	src/model/StartGWSInstanceRequest.cc
@@ -498,8 +488,6 @@ set(ehpc_src
 	src/model/StopVisualServiceResult.cc
 	src/model/SubmitJobRequest.cc
 	src/model/SubmitJobResult.cc
-	src/model/UnbindAccountToClusterUserRequest.cc
-	src/model/UnbindAccountToClusterUserResult.cc
 	src/model/UninstallSoftwareRequest.cc
 	src/model/UninstallSoftwareResult.cc
 	src/model/UpdateClusterVolumesRequest.cc

ehpc/include/alibabacloud/ehpc/EHPCClient.h

@@ -38,8 +38,6 @@
 #include "model/AddUsersResult.h"
 #include "model/ApplyNodesRequest.h"
 #include "model/ApplyNodesResult.h"
-#include "model/BindAccountToClusterUserRequest.h"
-#include "model/BindAccountToClusterUserResult.h"
 #include "model/CreateClusterRequest.h"
 #include "model/CreateClusterResult.h"
 #include "model/CreateGWSClusterRequest.h"
@@ -124,6 +122,8 @@
 #include "model/GetHybridClusterConfigResult.h"
 #include "model/GetIfEcsTypeSupportHtConfigRequest.h"
 #include "model/GetIfEcsTypeSupportHtConfigResult.h"
+#include "model/GetSchedulerInfoRequest.h"
+#include "model/GetSchedulerInfoResult.h"
 #include "model/GetVisualServiceStatusRequest.h"
 #include "model/GetVisualServiceStatusResult.h"
 #include "model/GetWorkbenchTokenRequest.h"
@@ -134,12 +134,8 @@
 #include "model/InstallSoftwareResult.h"
 #include "model/InvokeShellCommandRequest.h"
 #include "model/InvokeShellCommandResult.h"
-#include "model/ListAccountMappingRequest.h"
-#include "model/ListAccountMappingResult.h"
 #include "model/ListAvailableEcsTypesRequest.h"
 #include "model/ListAvailableEcsTypesResult.h"
-#include "model/ListAvailableFileSystemTypesRequest.h"
-#include "model/ListAvailableFileSystemTypesResult.h"
 #include "model/ListCloudMetricProfilingsRequest.h"
 #include "model/ListCloudMetricProfilingsResult.h"
 #include "model/ListClusterLogsRequest.h"
@@ -230,10 +226,10 @@
 #include "model/SetGWSInstanceNameResult.h"
 #include "model/SetGWSInstanceUserRequest.h"
 #include "model/SetGWSInstanceUserResult.h"
-#include "model/SetJobUserRequest.h"
-#include "model/SetJobUserResult.h"
 #include "model/SetQueueRequest.h"
 #include "model/SetQueueResult.h"
+#include "model/SetSchedulerInfoRequest.h"
+#include "model/SetSchedulerInfoResult.h"
 #include "model/StartClusterRequest.h"
 #include "model/StartClusterResult.h"
 #include "model/StartGWSInstanceRequest.h"
@@ -254,8 +250,6 @@
 #include "model/StopVisualServiceResult.h"
 #include "model/SubmitJobRequest.h"
 #include "model/SubmitJobResult.h"
-#include "model/UnbindAccountToClusterUserRequest.h"
-#include "model/UnbindAccountToClusterUserResult.h"
 #include "model/UninstallSoftwareRequest.h"
 #include "model/UninstallSoftwareResult.h"
 #include "model/UpdateClusterVolumesRequest.h"
@@ -297,9 +291,6 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::ApplyNodesResult> ApplyNodesOutcome;
 			typedef std::future<ApplyNodesOutcome> ApplyNodesOutcomeCallable;
 			typedef std::function<void(const EHPCClient*, const Model::ApplyNodesRequest&, const ApplyNodesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ApplyNodesAsyncHandler;
-			typedef Outcome<Error, Model::BindAccountToClusterUserResult> BindAccountToClusterUserOutcome;
-			typedef std::future<BindAccountToClusterUserOutcome> BindAccountToClusterUserOutcomeCallable;
-			typedef std::function<void(const EHPCClient*, const Model::BindAccountToClusterUserRequest&, const BindAccountToClusterUserOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> BindAccountToClusterUserAsyncHandler;
 			typedef Outcome<Error, Model::CreateClusterResult> CreateClusterOutcome;
 			typedef std::future<CreateClusterOutcome> CreateClusterOutcomeCallable;
 			typedef std::function<void(const EHPCClient*, const Model::CreateClusterRequest&, const CreateClusterOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateClusterAsyncHandler;
@@ -426,6 +417,9 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::GetIfEcsTypeSupportHtConfigResult> GetIfEcsTypeSupportHtConfigOutcome;
 			typedef std::future<GetIfEcsTypeSupportHtConfigOutcome> GetIfEcsTypeSupportHtConfigOutcomeCallable;
 			typedef std::function<void(const EHPCClient*, const Model::GetIfEcsTypeSupportHtConfigRequest&, const GetIfEcsTypeSupportHtConfigOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetIfEcsTypeSupportHtConfigAsyncHandler;
+			typedef Outcome<Error, Model::GetSchedulerInfoResult> GetSchedulerInfoOutcome;
+			typedef std::future<GetSchedulerInfoOutcome> GetSchedulerInfoOutcomeCallable;
+			typedef std::function<void(const EHPCClient*, const Model::GetSchedulerInfoRequest&, const GetSchedulerInfoOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetSchedulerInfoAsyncHandler;
 			typedef Outcome<Error, Model::GetVisualServiceStatusResult> GetVisualServiceStatusOutcome;
 			typedef std::future<GetVisualServiceStatusOutcome> GetVisualServiceStatusOutcomeCallable;
 			typedef std::function<void(const EHPCClient*, const Model::GetVisualServiceStatusRequest&, const GetVisualServiceStatusOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetVisualServiceStatusAsyncHandler;
@@ -441,15 +435,9 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::InvokeShellCommandResult> InvokeShellCommandOutcome;
 			typedef std::future<InvokeShellCommandOutcome> InvokeShellCommandOutcomeCallable;
 			typedef std::function<void(const EHPCClient*, const Model::InvokeShellCommandRequest&, const InvokeShellCommandOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> InvokeShellCommandAsyncHandler;
-			typedef Outcome<Error, Model::ListAccountMappingResult> ListAccountMappingOutcome;
-			typedef std::future<ListAccountMappingOutcome> ListAccountMappingOutcomeCallable;
-			typedef std::function<void(const EHPCClient*, const Model::ListAccountMappingRequest&, const ListAccountMappingOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListAccountMappingAsyncHandler;
 			typedef Outcome<Error, Model::ListAvailableEcsTypesResult> ListAvailableEcsTypesOutcome;
 			typedef std::future<ListAvailableEcsTypesOutcome> ListAvailableEcsTypesOutcomeCallable;
 			typedef std::function<void(const EHPCClient*, const Model::ListAvailableEcsTypesRequest&, const ListAvailableEcsTypesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListAvailableEcsTypesAsyncHandler;
-			typedef Outcome<Error, Model::ListAvailableFileSystemTypesResult> ListAvailableFileSystemTypesOutcome;
-			typedef std::future<ListAvailableFileSystemTypesOutcome> ListAvailableFileSystemTypesOutcomeCallable;
-			typedef std::function<void(const EHPCClient*, const Model::ListAvailableFileSystemTypesRequest&, const ListAvailableFileSystemTypesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListAvailableFileSystemTypesAsyncHandler;
 			typedef Outcome<Error, Model::ListCloudMetricProfilingsResult> ListCloudMetricProfilingsOutcome;
 			typedef std::future<ListCloudMetricProfilingsOutcome> ListCloudMetricProfilingsOutcomeCallable;
 			typedef std::function<void(const EHPCClient*, const Model::ListCloudMetricProfilingsRequest&, const ListCloudMetricProfilingsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListCloudMetricProfilingsAsyncHandler;
@@ -585,12 +573,12 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::SetGWSInstanceUserResult> SetGWSInstanceUserOutcome;
 			typedef std::future<SetGWSInstanceUserOutcome> SetGWSInstanceUserOutcomeCallable;
 			typedef std::function<void(const EHPCClient*, const Model::SetGWSInstanceUserRequest&, const SetGWSInstanceUserOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> SetGWSInstanceUserAsyncHandler;
-			typedef Outcome<Error, Model::SetJobUserResult> SetJobUserOutcome;
-			typedef std::future<SetJobUserOutcome> SetJobUserOutcomeCallable;
-			typedef std::function<void(const EHPCClient*, const Model::SetJobUserRequest&, const SetJobUserOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> SetJobUserAsyncHandler;
 			typedef Outcome<Error, Model::SetQueueResult> SetQueueOutcome;
 			typedef std::future<SetQueueOutcome> SetQueueOutcomeCallable;
 			typedef std::function<void(const EHPCClient*, const Model::SetQueueRequest&, const SetQueueOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> SetQueueAsyncHandler;
+			typedef Outcome<Error, Model::SetSchedulerInfoResult> SetSchedulerInfoOutcome;
+			typedef std::future<SetSchedulerInfoOutcome> SetSchedulerInfoOutcomeCallable;
+			typedef std::function<void(const EHPCClient*, const Model::SetSchedulerInfoRequest&, const SetSchedulerInfoOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> SetSchedulerInfoAsyncHandler;
 			typedef Outcome<Error, Model::StartClusterResult> StartClusterOutcome;
 			typedef std::future<StartClusterOutcome> StartClusterOutcomeCallable;
 			typedef std::function<void(const EHPCClient*, const Model::StartClusterRequest&, const StartClusterOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> StartClusterAsyncHandler;
@@ -621,9 +609,6 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::SubmitJobResult> SubmitJobOutcome;
 			typedef std::future<SubmitJobOutcome> SubmitJobOutcomeCallable;
 			typedef std::function<void(const EHPCClient*, const Model::SubmitJobRequest&, const SubmitJobOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> SubmitJobAsyncHandler;
-			typedef Outcome<Error, Model::UnbindAccountToClusterUserResult> UnbindAccountToClusterUserOutcome;
-			typedef std::future<UnbindAccountToClusterUserOutcome> UnbindAccountToClusterUserOutcomeCallable;
-			typedef std::function<void(const EHPCClient*, const Model::UnbindAccountToClusterUserRequest&, const UnbindAccountToClusterUserOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> UnbindAccountToClusterUserAsyncHandler;
 			typedef Outcome<Error, Model::UninstallSoftwareResult> UninstallSoftwareOutcome;
 			typedef std::future<UninstallSoftwareOutcome> UninstallSoftwareOutcomeCallable;
 			typedef std::function<void(const EHPCClient*, const Model::UninstallSoftwareRequest&, const UninstallSoftwareOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> UninstallSoftwareAsyncHandler;
@@ -665,9 +650,6 @@ namespace AlibabaCloud
 			ApplyNodesOutcome applyNodes(const Model::ApplyNodesRequest &request)const;
 			void applyNodesAsync(const Model::ApplyNodesRequest& request, const ApplyNodesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			ApplyNodesOutcomeCallable applyNodesCallable(const Model::ApplyNodesRequest& request) const;
-			BindAccountToClusterUserOutcome bindAccountToClusterUser(const Model::BindAccountToClusterUserRequest &request)const;
-			void bindAccountToClusterUserAsync(const Model::BindAccountToClusterUserRequest& request, const BindAccountToClusterUserAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
-			BindAccountToClusterUserOutcomeCallable bindAccountToClusterUserCallable(const Model::BindAccountToClusterUserRequest& request) const;
 			CreateClusterOutcome createCluster(const Model::CreateClusterRequest &request)const;
 			void createClusterAsync(const Model::CreateClusterRequest& request, const CreateClusterAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			CreateClusterOutcomeCallable createClusterCallable(const Model::CreateClusterRequest& request) const;
@@ -794,6 +776,9 @@ namespace AlibabaCloud
 			GetIfEcsTypeSupportHtConfigOutcome getIfEcsTypeSupportHtConfig(const Model::GetIfEcsTypeSupportHtConfigRequest &request)const;
 			void getIfEcsTypeSupportHtConfigAsync(const Model::GetIfEcsTypeSupportHtConfigRequest& request, const GetIfEcsTypeSupportHtConfigAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			GetIfEcsTypeSupportHtConfigOutcomeCallable getIfEcsTypeSupportHtConfigCallable(const Model::GetIfEcsTypeSupportHtConfigRequest& request) const;
+			GetSchedulerInfoOutcome getSchedulerInfo(const Model::GetSchedulerInfoRequest &request)const;
+			void getSchedulerInfoAsync(const Model::GetSchedulerInfoRequest& request, const GetSchedulerInfoAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			GetSchedulerInfoOutcomeCallable getSchedulerInfoCallable(const Model::GetSchedulerInfoRequest& request) const;
 			GetVisualServiceStatusOutcome getVisualServiceStatus(const Model::GetVisualServiceStatusRequest &request)const;
 			void getVisualServiceStatusAsync(const Model::GetVisualServiceStatusRequest& request, const GetVisualServiceStatusAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			GetVisualServiceStatusOutcomeCallable getVisualServiceStatusCallable(const Model::GetVisualServiceStatusRequest& request) const;
@@ -809,15 +794,9 @@ namespace AlibabaCloud
 			InvokeShellCommandOutcome invokeShellCommand(const Model::InvokeShellCommandRequest &request)const;
 			void invokeShellCommandAsync(const Model::InvokeShellCommandRequest& request, const InvokeShellCommandAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			InvokeShellCommandOutcomeCallable invokeShellCommandCallable(const Model::InvokeShellCommandRequest& request) const;
-			ListAccountMappingOutcome listAccountMapping(const Model::ListAccountMappingRequest &request)const;
-			void listAccountMappingAsync(const Model::ListAccountMappingRequest& request, const ListAccountMappingAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
-			ListAccountMappingOutcomeCallable listAccountMappingCallable(const Model::ListAccountMappingRequest& request) const;
 			ListAvailableEcsTypesOutcome listAvailableEcsTypes(const Model::ListAvailableEcsTypesRequest &request)const;
 			void listAvailableEcsTypesAsync(const Model::ListAvailableEcsTypesRequest& request, const ListAvailableEcsTypesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			ListAvailableEcsTypesOutcomeCallable listAvailableEcsTypesCallable(const Model::ListAvailableEcsTypesRequest& request) const;
-			ListAvailableFileSystemTypesOutcome listAvailableFileSystemTypes(const Model::ListAvailableFileSystemTypesRequest &request)const;
-			void listAvailableFileSystemTypesAsync(const Model::ListAvailableFileSystemTypesRequest& request, const ListAvailableFileSystemTypesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
-			ListAvailableFileSystemTypesOutcomeCallable listAvailableFileSystemTypesCallable(const Model::ListAvailableFileSystemTypesRequest& request) const;
 			ListCloudMetricProfilingsOutcome listCloudMetricProfilings(const Model::ListCloudMetricProfilingsRequest &request)const;
 			void listCloudMetricProfilingsAsync(const Model::ListCloudMetricProfilingsRequest& request, const ListCloudMetricProfilingsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			ListCloudMetricProfilingsOutcomeCallable listCloudMetricProfilingsCallable(const Model::ListCloudMetricProfilingsRequest& request) const;
@@ -953,12 +932,12 @@ namespace AlibabaCloud
 			SetGWSInstanceUserOutcome setGWSInstanceUser(const Model::SetGWSInstanceUserRequest &request)const;
 			void setGWSInstanceUserAsync(const Model::SetGWSInstanceUserRequest& request, const SetGWSInstanceUserAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			SetGWSInstanceUserOutcomeCallable setGWSInstanceUserCallable(const Model::SetGWSInstanceUserRequest& request) const;
-			SetJobUserOutcome setJobUser(const Model::SetJobUserRequest &request)const;
-			void setJobUserAsync(const Model::SetJobUserRequest& request, const SetJobUserAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
-			SetJobUserOutcomeCallable setJobUserCallable(const Model::SetJobUserRequest& request) const;
 			SetQueueOutcome setQueue(const Model::SetQueueRequest &request)const;
 			void setQueueAsync(const Model::SetQueueRequest& request, const SetQueueAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			SetQueueOutcomeCallable setQueueCallable(const Model::SetQueueRequest& request) const;
+			SetSchedulerInfoOutcome setSchedulerInfo(const Model::SetSchedulerInfoRequest &request)const;
+			void setSchedulerInfoAsync(const Model::SetSchedulerInfoRequest& request, const SetSchedulerInfoAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			SetSchedulerInfoOutcomeCallable setSchedulerInfoCallable(const Model::SetSchedulerInfoRequest& request) const;
 			StartClusterOutcome startCluster(const Model::StartClusterRequest &request)const;
 			void startClusterAsync(const Model::StartClusterRequest& request, const StartClusterAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			StartClusterOutcomeCallable startClusterCallable(const Model::StartClusterRequest& request) const;
@@ -989,9 +968,6 @@ namespace AlibabaCloud
 			SubmitJobOutcome submitJob(const Model::SubmitJobRequest &request)const;
 			void submitJobAsync(const Model::SubmitJobRequest& request, const SubmitJobAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			SubmitJobOutcomeCallable submitJobCallable(const Model::SubmitJobRequest& request) const;
-			UnbindAccountToClusterUserOutcome unbindAccountToClusterUser(const Model::UnbindAccountToClusterUserRequest &request)const;
-			void unbindAccountToClusterUserAsync(const Model::UnbindAccountToClusterUserRequest& request, const UnbindAccountToClusterUserAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
-			UnbindAccountToClusterUserOutcomeCallable unbindAccountToClusterUserCallable(const Model::UnbindAccountToClusterUserRequest& request) const;
 			UninstallSoftwareOutcome uninstallSoftware(const Model::UninstallSoftwareRequest &request)const;
 			void uninstallSoftwareAsync(const Model::UninstallSoftwareRequest& request, const UninstallSoftwareAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			UninstallSoftwareOutcomeCallable uninstallSoftwareCallable(const Model::UninstallSoftwareRequest& request) const;

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

@@ -75,6 +75,8 @@ namespace AlibabaCloud
 				void setComputeSpotStrategy(const std::string& computeSpotStrategy);
 				std::string getHostNameSuffix()const;
 				void setHostNameSuffix(const std::string& hostNameSuffix);
+				bool getSync()const;
+				void setSync(bool sync);
 				std::string getVSwitchId()const;
 				void setVSwitchId(const std::string& vSwitchId);
 				std::string getPeriodUnit()const;
@@ -115,6 +117,7 @@ namespace AlibabaCloud
 				std::string clusterId_;
 				std::string computeSpotStrategy_;
 				std::string hostNameSuffix_;
+				bool sync_;
 				std::string vSwitchId_;
 				std::string periodUnit_;
 				bool computeEnableHt_;

ehpc/include/alibabacloud/ehpc/model/ApplyNodesRequest.h

@@ -85,8 +85,12 @@ namespace AlibabaCloud
 				void setPriorityStrategy(const std::string& priorityStrategy);
 				std::string getInstanceFamilyLevel()const;
 				void setInstanceFamilyLevel(const std::string& instanceFamilyLevel);
+				int getRound()const;
+				void setRound(int round);
 				std::string getInternetChargeType()const;
 				void setInternetChargeType(const std::string& internetChargeType);
+				int getInterval()const;
+				void setInterval(int interval);
 				std::vector<InstanceTypeModel> getInstanceTypeModel()const;
 				void setInstanceTypeModel(const std::vector<InstanceTypeModel>& instanceTypeModel);
 				int getInternetMaxBandWidthIn()const;
@@ -116,7 +120,9 @@ namespace AlibabaCloud
 				std::string hostNameSuffix_;
 				std::string priorityStrategy_;
 				std::string instanceFamilyLevel_;
+				int round_;
 				std::string internetChargeType_;
+				int interval_;
 				std::vector<InstanceTypeModel> instanceTypeModel_;
 				int internetMaxBandWidthIn_;
 				int targetCapacity_;

ehpc/include/alibabacloud/ehpc/model/BindAccountToClusterUserRequest.h

@@ -1,63 +0,0 @@
-/*
- * 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_BINDACCOUNTTOCLUSTERUSERREQUEST_H_
-#define ALIBABACLOUD_EHPC_MODEL_BINDACCOUNTTOCLUSTERUSERREQUEST_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 BindAccountToClusterUserRequest : public RpcServiceRequest
-			{
-
-			public:
-				BindAccountToClusterUserRequest();
-				~BindAccountToClusterUserRequest();
-
-				std::string getUserPwd()const;
-				void setUserPwd(const std::string& userPwd);
-				std::string getClusterId()const;
-				void setClusterId(const std::string& clusterId);
-				std::string getAccessKeyId()const;
-				void setAccessKeyId(const std::string& accessKeyId);
-				std::string getAccountName()const;
-				void setAccountName(const std::string& accountName);
-				std::string getAccountUid()const;
-				void setAccountUid(const std::string& accountUid);
-				std::string getUserName()const;
-				void setUserName(const std::string& userName);
-
-            private:
-				std::string userPwd_;
-				std::string clusterId_;
-				std::string accessKeyId_;
-				std::string accountName_;
-				std::string accountUid_;
-				std::string userName_;
-
-			};
-		}
-	}
-}
-#endif // !ALIBABACLOUD_EHPC_MODEL_BINDACCOUNTTOCLUSTERUSERREQUEST_H_

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);
+				std::string getClusterVersion()const;
+				void setClusterVersion(const std::string& clusterVersion);
 				bool getIsComputeEss()const;
 				void setIsComputeEss(bool isComputeEss);
 				std::vector<Application> getApplication()const;
@@ -210,6 +212,7 @@ namespace AlibabaCloud
 				std::string volumeProtocol_;
 				std::string clientVersion_;
 				std::string osTag_;
+				std::string clusterVersion_;
 				bool isComputeEss_;
 				std::vector<Application> application_;
 				std::string ecsChargeType_;

ehpc/include/alibabacloud/ehpc/model/CreateJobFileResult.h

@@ -37,12 +37,10 @@ namespace AlibabaCloud
 				CreateJobFileResult();
 				explicit CreateJobFileResult(const std::string &payload);
 				~CreateJobFileResult();
-				std::string getTemplateId()const;
 
 			protected:
 				void parse(const std::string &payload);
 			private:
-				std::string templateId_;
 
 			};
 		}

ehpc/include/alibabacloud/ehpc/model/DeleteNodesRequest.h

@@ -44,6 +44,8 @@ namespace AlibabaCloud
 				void setInstance(const std::vector<Instance>& instance);
 				std::string getClusterId()const;
 				void setClusterId(const std::string& clusterId);
+				bool getSync()const;
+				void setSync(bool sync);
 				std::string getAccessKeyId()const;
 				void setAccessKeyId(const std::string& accessKeyId);
 				bool getReleaseInstance()const;
@@ -52,6 +54,7 @@ namespace AlibabaCloud
             private:
 				std::vector<Instance> instance_;
 				std::string clusterId_;
+				bool sync_;
 				std::string accessKeyId_;
 				bool releaseInstance_;
 

ehpc/include/alibabacloud/ehpc/model/GetAutoScaleConfigResult.h

@@ -44,13 +44,18 @@ namespace AlibabaCloud
 						std::string spotStrategy;
 					};
 					int minNodesInQueue;
+					std::string hostNameSuffix;
 					int maxNodesInQueue;
 					std::string resourceGroupId;
 					bool enableAutoGrow;
 					std::string queueImageId;
+					int systemDiskSize;
+					std::string systemDiskLevel;
+					bool enableAutoShrink;
+					std::string systemDiskCategory;
 					float spotPriceLimit;
+					std::string hostNamePrefix;
 					std::vector<QueueInfo::InstanceTypeInfo> instanceTypes;
-					bool enableAutoShrink;
 					std::string instanceType;
 					std::string queueName;
 					std::string spotStrategy;

ehpc/include/alibabacloud/ehpc/model/UnbindAccountToClusterUserRequest.h → ehpc/include/alibabacloud/ehpc/model/GetSchedulerInfoRequest.h

@@ -14,8 +14,8 @@
  * limitations under the License.
  */
 
-#ifndef ALIBABACLOUD_EHPC_MODEL_UNBINDACCOUNTTOCLUSTERUSERREQUEST_H_
-#define ALIBABACLOUD_EHPC_MODEL_UNBINDACCOUNTTOCLUSTERUSERREQUEST_H_
+#ifndef ALIBABACLOUD_EHPC_MODEL_GETSCHEDULERINFOREQUEST_H_
+#define ALIBABACLOUD_EHPC_MODEL_GETSCHEDULERINFOREQUEST_H_
 
 #include <string>
 #include <vector>
@@ -28,30 +28,35 @@ namespace AlibabaCloud
 	{
 		namespace Model
 		{
-			class ALIBABACLOUD_EHPC_EXPORT UnbindAccountToClusterUserRequest : public RpcServiceRequest
+			class ALIBABACLOUD_EHPC_EXPORT GetSchedulerInfoRequest : public RpcServiceRequest
 			{
+			public:
+				struct Scheduler
+				{
+					std::string schedName;
+				};
 
 			public:
-				UnbindAccountToClusterUserRequest();
-				~UnbindAccountToClusterUserRequest();
+				GetSchedulerInfoRequest();
+				~GetSchedulerInfoRequest();
 
 				std::string getClusterId()const;
 				void setClusterId(const std::string& clusterId);
 				std::string getAccessKeyId()const;
 				void setAccessKeyId(const std::string& accessKeyId);
-				std::string getAccountUid()const;
-				void setAccountUid(const std::string& accountUid);
-				std::string getUserName()const;
-				void setUserName(const std::string& userName);
+				std::vector<Scheduler> getScheduler()const;
+				void setScheduler(const std::vector<Scheduler>& scheduler);
+				std::string getRegionId()const;
+				void setRegionId(const std::string& regionId);
 
             private:
 				std::string clusterId_;
 				std::string accessKeyId_;
-				std::string accountUid_;
-				std::string userName_;
+				std::vector<Scheduler> scheduler_;
+				std::string regionId_;
 
 			};
 		}
 	}
 }
-#endif // !ALIBABACLOUD_EHPC_MODEL_UNBINDACCOUNTTOCLUSTERUSERREQUEST_H_
+#endif // !ALIBABACLOUD_EHPC_MODEL_GETSCHEDULERINFOREQUEST_H_

ehpc/include/alibabacloud/ehpc/model/ListAccountMappingResult.h → ehpc/include/alibabacloud/ehpc/model/GetSchedulerInfoResult.h

@@ -14,8 +14,8 @@
  * limitations under the License.
  */
 
-#ifndef ALIBABACLOUD_EHPC_MODEL_LISTACCOUNTMAPPINGRESULT_H_
-#define ALIBABACLOUD_EHPC_MODEL_LISTACCOUNTMAPPINGRESULT_H_
+#ifndef ALIBABACLOUD_EHPC_MODEL_GETSCHEDULERINFORESULT_H_
+#define ALIBABACLOUD_EHPC_MODEL_GETSCHEDULERINFORESULT_H_
 
 #include <string>
 #include <vector>
@@ -29,29 +29,28 @@ namespace AlibabaCloud
 	{
 		namespace Model
 		{
-			class ALIBABACLOUD_EHPC_EXPORT ListAccountMappingResult : public ServiceResult
+			class ALIBABACLOUD_EHPC_EXPORT GetSchedulerInfoResult : public ServiceResult
 			{
 			public:
-				struct UserMapping
+				struct SchedInfoItem
 				{
-					std::string userName;
-					std::string accountId;
-					std::string accountName;
+					std::string configuration;
+					std::string schedName;
 				};
 
 
-				ListAccountMappingResult();
-				explicit ListAccountMappingResult(const std::string &payload);
-				~ListAccountMappingResult();
-				std::vector<UserMapping> getUserMappings()const;
+				GetSchedulerInfoResult();
+				explicit GetSchedulerInfoResult(const std::string &payload);
+				~GetSchedulerInfoResult();
+				std::vector<SchedInfoItem> getSchedInfo()const;
 
 			protected:
 				void parse(const std::string &payload);
 			private:
-				std::vector<UserMapping> userMappings_;
+				std::vector<SchedInfoItem> schedInfo_;
 
 			};
 		}
 	}
 }
-#endif // !ALIBABACLOUD_EHPC_MODEL_LISTACCOUNTMAPPINGRESULT_H_
+#endif // !ALIBABACLOUD_EHPC_MODEL_GETSCHEDULERINFORESULT_H_

ehpc/include/alibabacloud/ehpc/model/ListAccountMappingRequest.h

@@ -1,51 +0,0 @@
-/*
- * 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_LISTACCOUNTMAPPINGREQUEST_H_
-#define ALIBABACLOUD_EHPC_MODEL_LISTACCOUNTMAPPINGREQUEST_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 ListAccountMappingRequest : public RpcServiceRequest
-			{
-
-			public:
-				ListAccountMappingRequest();
-				~ListAccountMappingRequest();
-
-				std::string getClusterId()const;
-				void setClusterId(const std::string& clusterId);
-				std::string getAccessKeyId()const;
-				void setAccessKeyId(const std::string& accessKeyId);
-
-            private:
-				std::string clusterId_;
-				std::string accessKeyId_;
-
-			};
-		}
-	}
-}
-#endif // !ALIBABACLOUD_EHPC_MODEL_LISTACCOUNTMAPPINGREQUEST_H_

ehpc/include/alibabacloud/ehpc/model/ListAvailableFileSystemTypesRequest.h

@@ -1,48 +0,0 @@
-/*
- * 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_LISTAVAILABLEFILESYSTEMTYPESREQUEST_H_
-#define ALIBABACLOUD_EHPC_MODEL_LISTAVAILABLEFILESYSTEMTYPESREQUEST_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 ListAvailableFileSystemTypesRequest : public RpcServiceRequest
-			{
-
-			public:
-				ListAvailableFileSystemTypesRequest();
-				~ListAvailableFileSystemTypesRequest();
-
-				std::string getAccessKeyId()const;
-				void setAccessKeyId(const std::string& accessKeyId);
-
-            private:
-				std::string accessKeyId_;
-
-			};
-		}
-	}
-}
-#endif // !ALIBABACLOUD_EHPC_MODEL_LISTAVAILABLEFILESYSTEMTYPESREQUEST_H_

ehpc/include/alibabacloud/ehpc/model/ListAvailableFileSystemTypesResult.h

@@ -1,58 +0,0 @@
-/*
- * 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_LISTAVAILABLEFILESYSTEMTYPESRESULT_H_
-#define ALIBABACLOUD_EHPC_MODEL_LISTAVAILABLEFILESYSTEMTYPESRESULT_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 ListAvailableFileSystemTypesResult : public ServiceResult
-			{
-			public:
-				struct FileSystemTypes
-				{
-					std::string protocolType;
-					std::string fileSystemType;
-					bool available;
-					std::vector<std::string> storageTypes;
-				};
-
-
-				ListAvailableFileSystemTypesResult();
-				explicit ListAvailableFileSystemTypesResult(const std::string &payload);
-				~ListAvailableFileSystemTypesResult();
-				std::vector<FileSystemTypes> getFileSystemTypeList()const;
-
-			protected:
-				void parse(const std::string &payload);
-			private:
-				std::vector<FileSystemTypes> fileSystemTypeList_;
-
-			};
-		}
-	}
-}
-#endif // !ALIBABACLOUD_EHPC_MODEL_LISTAVAILABLEFILESYSTEMTYPESRESULT_H_

ehpc/include/alibabacloud/ehpc/model/ListNodesNoPagingResult.h

@@ -59,7 +59,6 @@ namespace AlibabaCloud
 					std::string imageId;
 					bool htEnabled;
 					std::string id;
-					std::string regionId;
 					std::string lockReason;
 					std::string instanceType;
 					std::string hostName;
@@ -70,17 +69,11 @@ namespace AlibabaCloud
 				ListNodesNoPagingResult();
 				explicit ListNodesNoPagingResult(const std::string &payload);
 				~ListNodesNoPagingResult();
-				int getTotalCount()const;
-				int getPageSize()const;
-				int getPageNumber()const;
 				std::vector<NodeInfo> getNodes()const;
 
 			protected:
 				void parse(const std::string &payload);
 			private:
-				int totalCount_;
-				int pageSize_;
-				int pageNumber_;
 				std::vector<NodeInfo> nodes_;
 
 			};

ehpc/include/alibabacloud/ehpc/model/SetAutoScaleConfigRequest.h

@@ -33,25 +33,29 @@ namespace AlibabaCloud
 			public:
 				struct Queues
 				{
-					std::string spotStrategy;
 					std::string queueName;
-					int minNodesInQueue;
+					std::string systemDiskLevel;
 					struct InstanceTypes
 					{
 						std::string spotStrategy;
 						std::string vSwitchId;
 						std::string instanceType;
 						std::string zoneId;
-						std::string hostNamePrefix;
 						float spotPriceLimit;
 					};
 					std::vector<InstanceTypes> instanceTypes;
-					int maxNodesInQueue;
-					std::string instanceType;
-					std::string queueImageId;
 					bool enableAutoGrow;
 					float spotPriceLimit;
+					std::string hostNameSuffix;
 					bool enableAutoShrink;
+					std::string spotStrategy;
+					int minNodesInQueue;
+					std::string systemDiskCategory;
+					int maxNodesInQueue;
+					int systemDiskSize;
+					std::string instanceType;
+					std::string queueImageId;
+					std::string hostNamePrefix;
 				};
 
 			public:

ehpc/include/alibabacloud/ehpc/model/SetJobUserRequest.h

@@ -1,57 +0,0 @@
-/*
- * 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_SETJOBUSERREQUEST_H_
-#define ALIBABACLOUD_EHPC_MODEL_SETJOBUSERREQUEST_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 SetJobUserRequest : public RpcServiceRequest
-			{
-
-			public:
-				SetJobUserRequest();
-				~SetJobUserRequest();
-
-				std::string getRunasUserPassword()const;
-				void setRunasUserPassword(const std::string& runasUserPassword);
-				std::string getRunasUser()const;
-				void setRunasUser(const std::string& runasUser);
-				std::string getClusterId()const;
-				void setClusterId(const std::string& clusterId);
-				std::string getAccessKeyId()const;
-				void setAccessKeyId(const std::string& accessKeyId);
-
-            private:
-				std::string runasUserPassword_;
-				std::string runasUser_;
-				std::string clusterId_;
-				std::string accessKeyId_;
-
-			};
-		}
-	}
-}
-#endif // !ALIBABACLOUD_EHPC_MODEL_SETJOBUSERREQUEST_H_

ehpc/include/alibabacloud/ehpc/model/SetJobUserResult.h

@@ -1,49 +0,0 @@
-/*
- * 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_SETJOBUSERRESULT_H_
-#define ALIBABACLOUD_EHPC_MODEL_SETJOBUSERRESULT_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 SetJobUserResult : public ServiceResult
-			{
-			public:
-
-
-				SetJobUserResult();
-				explicit SetJobUserResult(const std::string &payload);
-				~SetJobUserResult();
-
-			protected:
-				void parse(const std::string &payload);
-			private:
-
-			};
-		}
-	}
-}
-#endif // !ALIBABACLOUD_EHPC_MODEL_SETJOBUSERRESULT_H_

ehpc/include/alibabacloud/ehpc/model/SetSchedulerInfoRequest.h

@@ -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.
+ */
+
+#ifndef ALIBABACLOUD_EHPC_MODEL_SETSCHEDULERINFOREQUEST_H_
+#define ALIBABACLOUD_EHPC_MODEL_SETSCHEDULERINFOREQUEST_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 SetSchedulerInfoRequest : public RpcServiceRequest
+			{
+			public:
+				struct SlurmInfo
+				{
+					int schedInterval;
+					int backfillInterval;
+				};
+				struct Scheduler
+				{
+					std::string schedName;
+				};
+				struct PbsInfo
+				{
+					int schedInterval;
+					struct ResourceLimit
+					{
+						int nodes;
+						std::string mem;
+						int cpus;
+						std::string user;
+						std::string queue;
+					};
+					std::vector<ResourceLimit> resourceLimit;
+					struct AclLimit
+					{
+						std::string aclUsers;
+						std::string queue;
+					};
+					std::vector<AclLimit> aclLimit;
+					int jobHistoryDuration;
+				};
+
+			public:
+				SetSchedulerInfoRequest();
+				~SetSchedulerInfoRequest();
+
+				std::vector<SlurmInfo> getSlurmInfo()const;
+				void setSlurmInfo(const std::vector<SlurmInfo>& slurmInfo);
+				std::string getClusterId()const;
+				void setClusterId(const std::string& clusterId);
+				std::string getAccessKeyId()const;
+				void setAccessKeyId(const std::string& accessKeyId);
+				std::vector<Scheduler> getScheduler()const;
+				void setScheduler(const std::vector<Scheduler>& scheduler);
+				std::string getRegionId()const;
+				void setRegionId(const std::string& regionId);
+				std::vector<PbsInfo> getPbsInfo()const;
+				void setPbsInfo(const std::vector<PbsInfo>& pbsInfo);
+
+            private:
+				std::vector<SlurmInfo> slurmInfo_;
+				std::string clusterId_;
+				std::string accessKeyId_;
+				std::vector<Scheduler> scheduler_;
+				std::string regionId_;
+				std::vector<PbsInfo> pbsInfo_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_EHPC_MODEL_SETSCHEDULERINFOREQUEST_H_

ehpc/include/alibabacloud/ehpc/model/BindAccountToClusterUserResult.h → ehpc/include/alibabacloud/ehpc/model/SetSchedulerInfoResult.h

@@ -14,8 +14,8 @@
  * limitations under the License.
  */
 
-#ifndef ALIBABACLOUD_EHPC_MODEL_BINDACCOUNTTOCLUSTERUSERRESULT_H_
-#define ALIBABACLOUD_EHPC_MODEL_BINDACCOUNTTOCLUSTERUSERRESULT_H_
+#ifndef ALIBABACLOUD_EHPC_MODEL_SETSCHEDULERINFORESULT_H_
+#define ALIBABACLOUD_EHPC_MODEL_SETSCHEDULERINFORESULT_H_
 
 #include <string>
 #include <vector>
@@ -29,21 +29,23 @@ namespace AlibabaCloud
 	{
 		namespace Model
 		{
-			class ALIBABACLOUD_EHPC_EXPORT BindAccountToClusterUserResult : public ServiceResult
+			class ALIBABACLOUD_EHPC_EXPORT SetSchedulerInfoResult : public ServiceResult
 			{
 			public:
 
 
-				BindAccountToClusterUserResult();
-				explicit BindAccountToClusterUserResult(const std::string &payload);
-				~BindAccountToClusterUserResult();
+				SetSchedulerInfoResult();
+				explicit SetSchedulerInfoResult(const std::string &payload);
+				~SetSchedulerInfoResult();
+				std::string getMessage()const;
 
 			protected:
 				void parse(const std::string &payload);
 			private:
+				std::string message_;
 
 			};
 		}
 	}
 }
-#endif // !ALIBABACLOUD_EHPC_MODEL_BINDACCOUNTTOCLUSTERUSERRESULT_H_
+#endif // !ALIBABACLOUD_EHPC_MODEL_SETSCHEDULERINFORESULT_H_

ehpc/include/alibabacloud/ehpc/model/UnbindAccountToClusterUserResult.h

@@ -1,49 +0,0 @@
-/*
- * 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_UNBINDACCOUNTTOCLUSTERUSERRESULT_H_
-#define ALIBABACLOUD_EHPC_MODEL_UNBINDACCOUNTTOCLUSTERUSERRESULT_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 UnbindAccountToClusterUserResult : public ServiceResult
-			{
-			public:
-
-
-				UnbindAccountToClusterUserResult();
-				explicit UnbindAccountToClusterUserResult(const std::string &payload);
-				~UnbindAccountToClusterUserResult();
-
-			protected:
-				void parse(const std::string &payload);
-			private:
-
-			};
-		}
-	}
-}
-#endif // !ALIBABACLOUD_EHPC_MODEL_UNBINDACCOUNTTOCLUSTERUSERRESULT_H_

ehpc/src/EHPCClient.cc

@@ -339,42 +339,6 @@ EHPCClient::ApplyNodesOutcomeCallable EHPCClient::applyNodesCallable(const Apply
 	return task->get_future();
 }
 
-EHPCClient::BindAccountToClusterUserOutcome EHPCClient::bindAccountToClusterUser(const BindAccountToClusterUserRequest &request) const
-{
-	auto endpointOutcome = endpointProvider_->getEndpoint();
-	if (!endpointOutcome.isSuccess())
-		return BindAccountToClusterUserOutcome(endpointOutcome.error());
-
-	auto outcome = makeRequest(endpointOutcome.result(), request);
-
-	if (outcome.isSuccess())
-		return BindAccountToClusterUserOutcome(BindAccountToClusterUserResult(outcome.result()));
-	else
-		return BindAccountToClusterUserOutcome(outcome.error());
-}
-
-void EHPCClient::bindAccountToClusterUserAsync(const BindAccountToClusterUserRequest& request, const BindAccountToClusterUserAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
-{
-	auto fn = [this, request, handler, context]()
-	{
-		handler(this, request, bindAccountToClusterUser(request), context);
-	};
-
-	asyncExecute(new Runnable(fn));
-}
-
-EHPCClient::BindAccountToClusterUserOutcomeCallable EHPCClient::bindAccountToClusterUserCallable(const BindAccountToClusterUserRequest &request) const
-{
-	auto task = std::make_shared<std::packaged_task<BindAccountToClusterUserOutcome()>>(
-			[this, request]()
-			{
-			return this->bindAccountToClusterUser(request);
-			});
-
-	asyncExecute(new Runnable([task]() { (*task)(); }));
-	return task->get_future();
-}
-
 EHPCClient::CreateClusterOutcome EHPCClient::createCluster(const CreateClusterRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -1887,6 +1851,42 @@ EHPCClient::GetIfEcsTypeSupportHtConfigOutcomeCallable EHPCClient::getIfEcsTypeS
 	return task->get_future();
 }
 
+EHPCClient::GetSchedulerInfoOutcome EHPCClient::getSchedulerInfo(const GetSchedulerInfoRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return GetSchedulerInfoOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return GetSchedulerInfoOutcome(GetSchedulerInfoResult(outcome.result()));
+	else
+		return GetSchedulerInfoOutcome(outcome.error());
+}
+
+void EHPCClient::getSchedulerInfoAsync(const GetSchedulerInfoRequest& request, const GetSchedulerInfoAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, getSchedulerInfo(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+EHPCClient::GetSchedulerInfoOutcomeCallable EHPCClient::getSchedulerInfoCallable(const GetSchedulerInfoRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<GetSchedulerInfoOutcome()>>(
+			[this, request]()
+			{
+			return this->getSchedulerInfo(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 EHPCClient::GetVisualServiceStatusOutcome EHPCClient::getVisualServiceStatus(const GetVisualServiceStatusRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -2067,42 +2067,6 @@ EHPCClient::InvokeShellCommandOutcomeCallable EHPCClient::invokeShellCommandCall
 	return task->get_future();
 }
 
-EHPCClient::ListAccountMappingOutcome EHPCClient::listAccountMapping(const ListAccountMappingRequest &request) const
-{
-	auto endpointOutcome = endpointProvider_->getEndpoint();
-	if (!endpointOutcome.isSuccess())
-		return ListAccountMappingOutcome(endpointOutcome.error());
-
-	auto outcome = makeRequest(endpointOutcome.result(), request);
-
-	if (outcome.isSuccess())
-		return ListAccountMappingOutcome(ListAccountMappingResult(outcome.result()));
-	else
-		return ListAccountMappingOutcome(outcome.error());
-}
-
-void EHPCClient::listAccountMappingAsync(const ListAccountMappingRequest& request, const ListAccountMappingAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
-{
-	auto fn = [this, request, handler, context]()
-	{
-		handler(this, request, listAccountMapping(request), context);
-	};
-
-	asyncExecute(new Runnable(fn));
-}
-
-EHPCClient::ListAccountMappingOutcomeCallable EHPCClient::listAccountMappingCallable(const ListAccountMappingRequest &request) const
-{
-	auto task = std::make_shared<std::packaged_task<ListAccountMappingOutcome()>>(
-			[this, request]()
-			{
-			return this->listAccountMapping(request);
-			});
-
-	asyncExecute(new Runnable([task]() { (*task)(); }));
-	return task->get_future();
-}
-
 EHPCClient::ListAvailableEcsTypesOutcome EHPCClient::listAvailableEcsTypes(const ListAvailableEcsTypesRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -2139,42 +2103,6 @@ EHPCClient::ListAvailableEcsTypesOutcomeCallable EHPCClient::listAvailableEcsTyp
 	return task->get_future();
 }
 
-EHPCClient::ListAvailableFileSystemTypesOutcome EHPCClient::listAvailableFileSystemTypes(const ListAvailableFileSystemTypesRequest &request) const
-{
-	auto endpointOutcome = endpointProvider_->getEndpoint();
-	if (!endpointOutcome.isSuccess())
-		return ListAvailableFileSystemTypesOutcome(endpointOutcome.error());
-
-	auto outcome = makeRequest(endpointOutcome.result(), request);
-
-	if (outcome.isSuccess())
-		return ListAvailableFileSystemTypesOutcome(ListAvailableFileSystemTypesResult(outcome.result()));
-	else
-		return ListAvailableFileSystemTypesOutcome(outcome.error());
-}
-
-void EHPCClient::listAvailableFileSystemTypesAsync(const ListAvailableFileSystemTypesRequest& request, const ListAvailableFileSystemTypesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
-{
-	auto fn = [this, request, handler, context]()
-	{
-		handler(this, request, listAvailableFileSystemTypes(request), context);
-	};
-
-	asyncExecute(new Runnable(fn));
-}
-
-EHPCClient::ListAvailableFileSystemTypesOutcomeCallable EHPCClient::listAvailableFileSystemTypesCallable(const ListAvailableFileSystemTypesRequest &request) const
-{
-	auto task = std::make_shared<std::packaged_task<ListAvailableFileSystemTypesOutcome()>>(
-			[this, request]()
-			{
-			return this->listAvailableFileSystemTypes(request);
-			});
-
-	asyncExecute(new Runnable([task]() { (*task)(); }));
-	return task->get_future();
-}
-
 EHPCClient::ListCloudMetricProfilingsOutcome EHPCClient::listCloudMetricProfilings(const ListCloudMetricProfilingsRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -3795,72 +3723,72 @@ EHPCClient::SetGWSInstanceUserOutcomeCallable EHPCClient::setGWSInstanceUserCall
 	return task->get_future();
 }
 
-EHPCClient::SetJobUserOutcome EHPCClient::setJobUser(const SetJobUserRequest &request) const
+EHPCClient::SetQueueOutcome EHPCClient::setQueue(const SetQueueRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
 	if (!endpointOutcome.isSuccess())
-		return SetJobUserOutcome(endpointOutcome.error());
+		return SetQueueOutcome(endpointOutcome.error());
 
 	auto outcome = makeRequest(endpointOutcome.result(), request);
 
 	if (outcome.isSuccess())
-		return SetJobUserOutcome(SetJobUserResult(outcome.result()));
+		return SetQueueOutcome(SetQueueResult(outcome.result()));
 	else
-		return SetJobUserOutcome(outcome.error());
+		return SetQueueOutcome(outcome.error());
 }
 
-void EHPCClient::setJobUserAsync(const SetJobUserRequest& request, const SetJobUserAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+void EHPCClient::setQueueAsync(const SetQueueRequest& request, const SetQueueAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
 {
 	auto fn = [this, request, handler, context]()
 	{
-		handler(this, request, setJobUser(request), context);
+		handler(this, request, setQueue(request), context);
 	};
 
 	asyncExecute(new Runnable(fn));
 }
 
-EHPCClient::SetJobUserOutcomeCallable EHPCClient::setJobUserCallable(const SetJobUserRequest &request) const
+EHPCClient::SetQueueOutcomeCallable EHPCClient::setQueueCallable(const SetQueueRequest &request) const
 {
-	auto task = std::make_shared<std::packaged_task<SetJobUserOutcome()>>(
+	auto task = std::make_shared<std::packaged_task<SetQueueOutcome()>>(
 			[this, request]()
 			{
-			return this->setJobUser(request);
+			return this->setQueue(request);
 			});
 
 	asyncExecute(new Runnable([task]() { (*task)(); }));
 	return task->get_future();
 }
 
-EHPCClient::SetQueueOutcome EHPCClient::setQueue(const SetQueueRequest &request) const
+EHPCClient::SetSchedulerInfoOutcome EHPCClient::setSchedulerInfo(const SetSchedulerInfoRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
 	if (!endpointOutcome.isSuccess())
-		return SetQueueOutcome(endpointOutcome.error());
+		return SetSchedulerInfoOutcome(endpointOutcome.error());
 
 	auto outcome = makeRequest(endpointOutcome.result(), request);
 
 	if (outcome.isSuccess())
-		return SetQueueOutcome(SetQueueResult(outcome.result()));
+		return SetSchedulerInfoOutcome(SetSchedulerInfoResult(outcome.result()));
 	else
-		return SetQueueOutcome(outcome.error());
+		return SetSchedulerInfoOutcome(outcome.error());
 }
 
-void EHPCClient::setQueueAsync(const SetQueueRequest& request, const SetQueueAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+void EHPCClient::setSchedulerInfoAsync(const SetSchedulerInfoRequest& request, const SetSchedulerInfoAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
 {
 	auto fn = [this, request, handler, context]()
 	{
-		handler(this, request, setQueue(request), context);
+		handler(this, request, setSchedulerInfo(request), context);
 	};
 
 	asyncExecute(new Runnable(fn));
 }
 
-EHPCClient::SetQueueOutcomeCallable EHPCClient::setQueueCallable(const SetQueueRequest &request) const
+EHPCClient::SetSchedulerInfoOutcomeCallable EHPCClient::setSchedulerInfoCallable(const SetSchedulerInfoRequest &request) const
 {
-	auto task = std::make_shared<std::packaged_task<SetQueueOutcome()>>(
+	auto task = std::make_shared<std::packaged_task<SetSchedulerInfoOutcome()>>(
 			[this, request]()
 			{
-			return this->setQueue(request);
+			return this->setSchedulerInfo(request);
 			});
 
 	asyncExecute(new Runnable([task]() { (*task)(); }));
@@ -4227,42 +4155,6 @@ EHPCClient::SubmitJobOutcomeCallable EHPCClient::submitJobCallable(const SubmitJ
 	return task->get_future();
 }
 
-EHPCClient::UnbindAccountToClusterUserOutcome EHPCClient::unbindAccountToClusterUser(const UnbindAccountToClusterUserRequest &request) const
-{
-	auto endpointOutcome = endpointProvider_->getEndpoint();
-	if (!endpointOutcome.isSuccess())
-		return UnbindAccountToClusterUserOutcome(endpointOutcome.error());
-
-	auto outcome = makeRequest(endpointOutcome.result(), request);
-
-	if (outcome.isSuccess())
-		return UnbindAccountToClusterUserOutcome(UnbindAccountToClusterUserResult(outcome.result()));
-	else
-		return UnbindAccountToClusterUserOutcome(outcome.error());
-}
-
-void EHPCClient::unbindAccountToClusterUserAsync(const UnbindAccountToClusterUserRequest& request, const UnbindAccountToClusterUserAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
-{
-	auto fn = [this, request, handler, context]()
-	{
-		handler(this, request, unbindAccountToClusterUser(request), context);
-	};
-
-	asyncExecute(new Runnable(fn));
-}
-
-EHPCClient::UnbindAccountToClusterUserOutcomeCallable EHPCClient::unbindAccountToClusterUserCallable(const UnbindAccountToClusterUserRequest &request) const
-{
-	auto task = std::make_shared<std::packaged_task<UnbindAccountToClusterUserOutcome()>>(
-			[this, request]()
-			{
-			return this->unbindAccountToClusterUser(request);
-			});
-
-	asyncExecute(new Runnable([task]() { (*task)(); }));
-	return task->get_future();
-}
-
 EHPCClient::UninstallSoftwareOutcome EHPCClient::uninstallSoftware(const UninstallSoftwareRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();

ehpc/src/model/AddNodesRequest.cc

@@ -247,6 +247,17 @@ void AddNodesRequest::setHostNameSuffix(const std::string& hostNameSuffix)
 	setParameter("HostNameSuffix", hostNameSuffix);
 }
 
+bool AddNodesRequest::getSync()const
+{
+	return sync_;
+}
+
+void AddNodesRequest::setSync(bool sync)
+{
+	sync_ = sync;
+	setParameter("Sync", sync ? "true" : "false");
+}
+
 std::string AddNodesRequest::getVSwitchId()const
 {
 	return vSwitchId_;

ehpc/src/model/ApplyNodesRequest.cc

@@ -241,6 +241,17 @@ void ApplyNodesRequest::setInstanceFamilyLevel(const std::string& instanceFamily
 	setParameter("InstanceFamilyLevel", instanceFamilyLevel);
 }
 
+int ApplyNodesRequest::getRound()const
+{
+	return round_;
+}
+
+void ApplyNodesRequest::setRound(int round)
+{
+	round_ = round;
+	setParameter("Round", std::to_string(round));
+}
+
 std::string ApplyNodesRequest::getInternetChargeType()const
 {
 	return internetChargeType_;
@@ -252,6 +263,17 @@ void ApplyNodesRequest::setInternetChargeType(const std::string& internetChargeT
 	setParameter("InternetChargeType", internetChargeType);
 }
 
+int ApplyNodesRequest::getInterval()const
+{
+	return interval_;
+}
+
+void ApplyNodesRequest::setInterval(int interval)
+{
+	interval_ = interval;
+	setParameter("Interval", std::to_string(interval));
+}
+
 std::vector<ApplyNodesRequest::InstanceTypeModel> ApplyNodesRequest::getInstanceTypeModel()const
 {
 	return instanceTypeModel_;

ehpc/src/model/BindAccountToClusterUserRequest.cc

@@ -1,95 +0,0 @@
-/*
- * 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/BindAccountToClusterUserRequest.h>
-
-using AlibabaCloud::EHPC::Model::BindAccountToClusterUserRequest;
-
-BindAccountToClusterUserRequest::BindAccountToClusterUserRequest() :
-	RpcServiceRequest("ehpc", "2018-04-12", "BindAccountToClusterUser")
-{
-	setMethod(HttpRequest::Method::Get);
-}
-
-BindAccountToClusterUserRequest::~BindAccountToClusterUserRequest()
-{}
-
-std::string BindAccountToClusterUserRequest::getUserPwd()const
-{
-	return userPwd_;
-}
-
-void BindAccountToClusterUserRequest::setUserPwd(const std::string& userPwd)
-{
-	userPwd_ = userPwd;
-	setParameter("UserPwd", userPwd);
-}
-
-std::string BindAccountToClusterUserRequest::getClusterId()const
-{
-	return clusterId_;
-}
-
-void BindAccountToClusterUserRequest::setClusterId(const std::string& clusterId)
-{
-	clusterId_ = clusterId;
-	setParameter("ClusterId", clusterId);
-}
-
-std::string BindAccountToClusterUserRequest::getAccessKeyId()const
-{
-	return accessKeyId_;
-}
-
-void BindAccountToClusterUserRequest::setAccessKeyId(const std::string& accessKeyId)
-{
-	accessKeyId_ = accessKeyId;
-	setParameter("AccessKeyId", accessKeyId);
-}
-
-std::string BindAccountToClusterUserRequest::getAccountName()const
-{
-	return accountName_;
-}
-
-void BindAccountToClusterUserRequest::setAccountName(const std::string& accountName)
-{
-	accountName_ = accountName;
-	setParameter("AccountName", accountName);
-}
-
-std::string BindAccountToClusterUserRequest::getAccountUid()const
-{
-	return accountUid_;
-}
-
-void BindAccountToClusterUserRequest::setAccountUid(const std::string& accountUid)
-{
-	accountUid_ = accountUid;
-	setParameter("AccountUid", accountUid);
-}
-
-std::string BindAccountToClusterUserRequest::getUserName()const
-{
-	return userName_;
-}
-
-void BindAccountToClusterUserRequest::setUserName(const std::string& userName)
-{
-	userName_ = userName;
-	setParameter("UserName", userName);
-}
-

ehpc/src/model/BindAccountToClusterUserResult.cc

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

ehpc/src/model/CreateClusterRequest.cc

@@ -521,6 +521,17 @@ void CreateClusterRequest::setOsTag(const std::string& osTag)
 	setParameter("OsTag", osTag);
 }
 
+std::string CreateClusterRequest::getClusterVersion()const
+{
+	return clusterVersion_;
+}
+
+void CreateClusterRequest::setClusterVersion(const std::string& clusterVersion)
+{
+	clusterVersion_ = clusterVersion;
+	setParameter("ClusterVersion", clusterVersion);
+}
+
 bool CreateClusterRequest::getIsComputeEss()const
 {
 	return isComputeEss_;

ehpc/src/model/CreateJobFileResult.cc

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

ehpc/src/model/DeleteNodesRequest.cc

@@ -53,6 +53,17 @@ void DeleteNodesRequest::setClusterId(const std::string& clusterId)
 	setParameter("ClusterId", clusterId);
 }
 
+bool DeleteNodesRequest::getSync()const
+{
+	return sync_;
+}
+
+void DeleteNodesRequest::setSync(bool sync)
+{
+	sync_ = sync;
+	setParameter("Sync", sync ? "true" : "false");
+}
+
 std::string DeleteNodesRequest::getAccessKeyId()const
 {
 	return accessKeyId_;

ehpc/src/model/GetAutoScaleConfigResult.cc

@@ -63,6 +63,16 @@ void GetAutoScaleConfigResult::parse(const std::string &payload)
 			queuesObject.minNodesInQueue = std::stoi(valueQueuesQueueInfo["MinNodesInQueue"].asString());
 		if(!valueQueuesQueueInfo["QueueImageId"].isNull())
 			queuesObject.queueImageId = valueQueuesQueueInfo["QueueImageId"].asString();
+		if(!valueQueuesQueueInfo["HostNamePrefix"].isNull())
+			queuesObject.hostNamePrefix = valueQueuesQueueInfo["HostNamePrefix"].asString();
+		if(!valueQueuesQueueInfo["HostNameSuffix"].isNull())
+			queuesObject.hostNameSuffix = valueQueuesQueueInfo["HostNameSuffix"].asString();
+		if(!valueQueuesQueueInfo["SystemDiskSize"].isNull())
+			queuesObject.systemDiskSize = std::stoi(valueQueuesQueueInfo["SystemDiskSize"].asString());
+		if(!valueQueuesQueueInfo["SystemDiskCategory"].isNull())
+			queuesObject.systemDiskCategory = valueQueuesQueueInfo["SystemDiskCategory"].asString();
+		if(!valueQueuesQueueInfo["SystemDiskLevel"].isNull())
+			queuesObject.systemDiskLevel = valueQueuesQueueInfo["SystemDiskLevel"].asString();
 		auto allInstanceTypesNode = valueQueuesQueueInfo["InstanceTypes"]["InstanceTypeInfo"];
 		for (auto valueQueuesQueueInfoInstanceTypesInstanceTypeInfo : allInstanceTypesNode)
 		{

ehpc/src/model/GetSchedulerInfoRequest.cc

@@ -0,0 +1,77 @@
+/*
+ * 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("ClusterId", clusterId);
+}
+
+std::string GetSchedulerInfoRequest::getAccessKeyId()const
+{
+	return accessKeyId_;
+}
+
+void GetSchedulerInfoRequest::setAccessKeyId(const std::string& accessKeyId)
+{
+	accessKeyId_ = accessKeyId;
+	setParameter("AccessKeyId", accessKeyId);
+}
+
+std::vector<GetSchedulerInfoRequest::Scheduler> GetSchedulerInfoRequest::getScheduler()const
+{
+	return scheduler_;
+}
+
+void GetSchedulerInfoRequest::setScheduler(const std::vector<Scheduler>& scheduler)
+{
+	scheduler_ = scheduler;
+	for(int dep1 = 0; dep1!= scheduler.size(); dep1++) {
+		auto schedulerObj = scheduler.at(dep1);
+		std::string schedulerObjStr = "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("RegionId", regionId);
+}
+

ehpc/src/model/UnbindAccountToClusterUserResult.cc → ehpc/src/model/GetSchedulerInfoResult.cc

@@ -14,31 +14,46 @@
  * limitations under the License.
  */
 
-#include <alibabacloud/ehpc/model/UnbindAccountToClusterUserResult.h>
+#include <alibabacloud/ehpc/model/GetSchedulerInfoResult.h>
 #include <json/json.h>
 
 using namespace AlibabaCloud::EHPC;
 using namespace AlibabaCloud::EHPC::Model;
 
-UnbindAccountToClusterUserResult::UnbindAccountToClusterUserResult() :
+GetSchedulerInfoResult::GetSchedulerInfoResult() :
 	ServiceResult()
 {}
 
-UnbindAccountToClusterUserResult::UnbindAccountToClusterUserResult(const std::string &payload) :
+GetSchedulerInfoResult::GetSchedulerInfoResult(const std::string &payload) :
 	ServiceResult()
 {
 	parse(payload);
 }
 
-UnbindAccountToClusterUserResult::~UnbindAccountToClusterUserResult()
+GetSchedulerInfoResult::~GetSchedulerInfoResult()
 {}
 
-void UnbindAccountToClusterUserResult::parse(const std::string &payload)
+void GetSchedulerInfoResult::parse(const std::string &payload)
 {
 	Json::Reader reader;
 	Json::Value value;
 	reader.parse(payload, value);
 	setRequestId(value["RequestId"].asString());
+	auto allSchedInfoNode = value["SchedInfo"]["SchedInfoItem"];
+	for (auto valueSchedInfoSchedInfoItem : allSchedInfoNode)
+	{
+		SchedInfoItem schedInfoObject;
+		if(!valueSchedInfoSchedInfoItem["SchedName"].isNull())
+			schedInfoObject.schedName = valueSchedInfoSchedInfoItem["SchedName"].asString();
+		if(!valueSchedInfoSchedInfoItem["Configuration"].isNull())
+			schedInfoObject.configuration = valueSchedInfoSchedInfoItem["Configuration"].asString();
+		schedInfo_.push_back(schedInfoObject);
+	}
 
 }
 
+std::vector<GetSchedulerInfoResult::SchedInfoItem> GetSchedulerInfoResult::getSchedInfo()const
+{
+	return schedInfo_;
+}
+

ehpc/src/model/ListAccountMappingRequest.cc

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

ehpc/src/model/ListAccountMappingResult.cc

@@ -1,61 +0,0 @@
-/*
- * 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/ListAccountMappingResult.h>
-#include <json/json.h>
-
-using namespace AlibabaCloud::EHPC;
-using namespace AlibabaCloud::EHPC::Model;
-
-ListAccountMappingResult::ListAccountMappingResult() :
-	ServiceResult()
-{}
-
-ListAccountMappingResult::ListAccountMappingResult(const std::string &payload) :
-	ServiceResult()
-{
-	parse(payload);
-}
-
-ListAccountMappingResult::~ListAccountMappingResult()
-{}
-
-void ListAccountMappingResult::parse(const std::string &payload)
-{
-	Json::Reader reader;
-	Json::Value value;
-	reader.parse(payload, value);
-	setRequestId(value["RequestId"].asString());
-	auto allUserMappingsNode = value["UserMappings"]["UserMapping"];
-	for (auto valueUserMappingsUserMapping : allUserMappingsNode)
-	{
-		UserMapping userMappingsObject;
-		if(!valueUserMappingsUserMapping["UserName"].isNull())
-			userMappingsObject.userName = valueUserMappingsUserMapping["UserName"].asString();
-		if(!valueUserMappingsUserMapping["AccountId"].isNull())
-			userMappingsObject.accountId = valueUserMappingsUserMapping["AccountId"].asString();
-		if(!valueUserMappingsUserMapping["AccountName"].isNull())
-			userMappingsObject.accountName = valueUserMappingsUserMapping["AccountName"].asString();
-		userMappings_.push_back(userMappingsObject);
-	}
-
-}
-
-std::vector<ListAccountMappingResult::UserMapping> ListAccountMappingResult::getUserMappings()const
-{
-	return userMappings_;
-}
-

ehpc/src/model/ListAvailableFileSystemTypesRequest.cc

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

ehpc/src/model/ListAvailableFileSystemTypesResult.cc

@@ -1,64 +0,0 @@
-/*
- * 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/ListAvailableFileSystemTypesResult.h>
-#include <json/json.h>
-
-using namespace AlibabaCloud::EHPC;
-using namespace AlibabaCloud::EHPC::Model;
-
-ListAvailableFileSystemTypesResult::ListAvailableFileSystemTypesResult() :
-	ServiceResult()
-{}
-
-ListAvailableFileSystemTypesResult::ListAvailableFileSystemTypesResult(const std::string &payload) :
-	ServiceResult()
-{
-	parse(payload);
-}
-
-ListAvailableFileSystemTypesResult::~ListAvailableFileSystemTypesResult()
-{}
-
-void ListAvailableFileSystemTypesResult::parse(const std::string &payload)
-{
-	Json::Reader reader;
-	Json::Value value;
-	reader.parse(payload, value);
-	setRequestId(value["RequestId"].asString());
-	auto allFileSystemTypeListNode = value["FileSystemTypeList"]["FileSystemTypes"];
-	for (auto valueFileSystemTypeListFileSystemTypes : allFileSystemTypeListNode)
-	{
-		FileSystemTypes fileSystemTypeListObject;
-		if(!valueFileSystemTypeListFileSystemTypes["FileSystemType"].isNull())
-			fileSystemTypeListObject.fileSystemType = valueFileSystemTypeListFileSystemTypes["FileSystemType"].asString();
-		if(!valueFileSystemTypeListFileSystemTypes["Available"].isNull())
-			fileSystemTypeListObject.available = valueFileSystemTypeListFileSystemTypes["Available"].asString() == "true";
-		if(!valueFileSystemTypeListFileSystemTypes["ProtocolType"].isNull())
-			fileSystemTypeListObject.protocolType = valueFileSystemTypeListFileSystemTypes["ProtocolType"].asString();
-		auto allStorageTypes = value["StorageTypes"]["StorageType"];
-		for (auto value : allStorageTypes)
-			fileSystemTypeListObject.storageTypes.push_back(value.asString());
-		fileSystemTypeList_.push_back(fileSystemTypeListObject);
-	}
-
-}
-
-std::vector<ListAvailableFileSystemTypesResult::FileSystemTypes> ListAvailableFileSystemTypesResult::getFileSystemTypeList()const
-{
-	return fileSystemTypeList_;
-}
-

ehpc/src/model/ListNodesNoPagingResult.cc

@@ -47,8 +47,6 @@ void ListNodesNoPagingResult::parse(const std::string &payload)
 			nodesObject.id = valueNodesNodeInfo["Id"].asString();
 		if(!valueNodesNodeInfo["HostName"].isNull())
 			nodesObject.hostName = valueNodesNodeInfo["HostName"].asString();
-		if(!valueNodesNodeInfo["RegionId"].isNull())
-			nodesObject.regionId = valueNodesNodeInfo["RegionId"].asString();
 		if(!valueNodesNodeInfo["Status"].isNull())
 			nodesObject.status = valueNodesNodeInfo["Status"].asString();
 		if(!valueNodesNodeInfo["Version"].isNull())
@@ -92,30 +90,9 @@ void ListNodesNoPagingResult::parse(const std::string &payload)
 			nodesObject.roles.push_back(value.asString());
 		nodes_.push_back(nodesObject);
 	}
-	if(!value["TotalCount"].isNull())
-		totalCount_ = std::stoi(value["TotalCount"].asString());
-	if(!value["PageNumber"].isNull())
-		pageNumber_ = std::stoi(value["PageNumber"].asString());
-	if(!value["PageSize"].isNull())
-		pageSize_ = std::stoi(value["PageSize"].asString());
 
 }
 
-int ListNodesNoPagingResult::getTotalCount()const
-{
-	return totalCount_;
-}
-
-int ListNodesNoPagingResult::getPageSize()const
-{
-	return pageSize_;
-}
-
-int ListNodesNoPagingResult::getPageNumber()const
-{
-	return pageNumber_;
-}
-
 std::vector<ListNodesNoPagingResult::NodeInfo> ListNodesNoPagingResult::getNodes()const
 {
 	return nodes_;

ehpc/src/model/SetAutoScaleConfigRequest.cc

@@ -181,9 +181,8 @@ void SetAutoScaleConfigRequest::setQueues(const std::vector<Queues>& queues)
 	for(int dep1 = 0; dep1!= queues.size(); dep1++) {
 		auto queuesObj = queues.at(dep1);
 		std::string queuesObjStr = "Queues." + std::to_string(dep1 + 1);
-		setParameter(queuesObjStr + ".SpotStrategy", queuesObj.spotStrategy);
 		setParameter(queuesObjStr + ".QueueName", queuesObj.queueName);
-		setParameter(queuesObjStr + ".MinNodesInQueue", std::to_string(queuesObj.minNodesInQueue));
+		setParameter(queuesObjStr + ".SystemDiskLevel", queuesObj.systemDiskLevel);
 		for(int dep2 = 0; dep2!= queuesObj.instanceTypes.size(); dep2++) {
 			auto instanceTypesObj = queuesObj.instanceTypes.at(dep2);
 			std::string instanceTypesObjStr = queuesObjStr + "InstanceTypes." + std::to_string(dep2 + 1);
@@ -191,15 +190,20 @@ void SetAutoScaleConfigRequest::setQueues(const std::vector<Queues>& queues)
 			setParameter(instanceTypesObjStr + ".VSwitchId", instanceTypesObj.vSwitchId);
 			setParameter(instanceTypesObjStr + ".InstanceType", instanceTypesObj.instanceType);
 			setParameter(instanceTypesObjStr + ".ZoneId", instanceTypesObj.zoneId);
-			setParameter(instanceTypesObjStr + ".HostNamePrefix", instanceTypesObj.hostNamePrefix);
 			setParameter(instanceTypesObjStr + ".SpotPriceLimit", std::to_string(instanceTypesObj.spotPriceLimit));
 		}
-		setParameter(queuesObjStr + ".MaxNodesInQueue", std::to_string(queuesObj.maxNodesInQueue));
-		setParameter(queuesObjStr + ".InstanceType", queuesObj.instanceType);
-		setParameter(queuesObjStr + ".QueueImageId", queuesObj.queueImageId);
 		setParameter(queuesObjStr + ".EnableAutoGrow", queuesObj.enableAutoGrow ? "true" : "false");
 		setParameter(queuesObjStr + ".SpotPriceLimit", std::to_string(queuesObj.spotPriceLimit));
+		setParameter(queuesObjStr + ".HostNameSuffix", queuesObj.hostNameSuffix);
 		setParameter(queuesObjStr + ".EnableAutoShrink", queuesObj.enableAutoShrink ? "true" : "false");
+		setParameter(queuesObjStr + ".SpotStrategy", queuesObj.spotStrategy);
+		setParameter(queuesObjStr + ".MinNodesInQueue", std::to_string(queuesObj.minNodesInQueue));
+		setParameter(queuesObjStr + ".SystemDiskCategory", queuesObj.systemDiskCategory);
+		setParameter(queuesObjStr + ".MaxNodesInQueue", std::to_string(queuesObj.maxNodesInQueue));
+		setParameter(queuesObjStr + ".SystemDiskSize", std::to_string(queuesObj.systemDiskSize));
+		setParameter(queuesObjStr + ".InstanceType", queuesObj.instanceType);
+		setParameter(queuesObjStr + ".QueueImageId", queuesObj.queueImageId);
+		setParameter(queuesObjStr + ".HostNamePrefix", queuesObj.hostNamePrefix);
 	}
 }
 

ehpc/src/model/SetJobUserRequest.cc

@@ -1,73 +0,0 @@
-/*
- * 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/SetJobUserRequest.h>
-
-using AlibabaCloud::EHPC::Model::SetJobUserRequest;
-
-SetJobUserRequest::SetJobUserRequest() :
-	RpcServiceRequest("ehpc", "2018-04-12", "SetJobUser")
-{
-	setMethod(HttpRequest::Method::Get);
-}
-
-SetJobUserRequest::~SetJobUserRequest()
-{}
-
-std::string SetJobUserRequest::getRunasUserPassword()const
-{
-	return runasUserPassword_;
-}
-
-void SetJobUserRequest::setRunasUserPassword(const std::string& runasUserPassword)
-{
-	runasUserPassword_ = runasUserPassword;
-	setParameter("RunasUserPassword", runasUserPassword);
-}
-
-std::string SetJobUserRequest::getRunasUser()const
-{
-	return runasUser_;
-}
-
-void SetJobUserRequest::setRunasUser(const std::string& runasUser)
-{
-	runasUser_ = runasUser;
-	setParameter("RunasUser", runasUser);
-}
-
-std::string SetJobUserRequest::getClusterId()const
-{
-	return clusterId_;
-}
-
-void SetJobUserRequest::setClusterId(const std::string& clusterId)
-{
-	clusterId_ = clusterId;
-	setParameter("ClusterId", clusterId);
-}
-
-std::string SetJobUserRequest::getAccessKeyId()const
-{
-	return accessKeyId_;
-}
-
-void SetJobUserRequest::setAccessKeyId(const std::string& accessKeyId)
-{
-	accessKeyId_ = accessKeyId;
-	setParameter("AccessKeyId", accessKeyId);
-}
-

ehpc/src/model/SetSchedulerInfoRequest.cc

@@ -0,0 +1,124 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/ehpc/model/SetSchedulerInfoRequest.h>
+
+using AlibabaCloud::EHPC::Model::SetSchedulerInfoRequest;
+
+SetSchedulerInfoRequest::SetSchedulerInfoRequest() :
+	RpcServiceRequest("ehpc", "2018-04-12", "SetSchedulerInfo")
+{
+	setMethod(HttpRequest::Method::Get);
+}
+
+SetSchedulerInfoRequest::~SetSchedulerInfoRequest()
+{}
+
+std::vector<SetSchedulerInfoRequest::SlurmInfo> SetSchedulerInfoRequest::getSlurmInfo()const
+{
+	return slurmInfo_;
+}
+
+void SetSchedulerInfoRequest::setSlurmInfo(const std::vector<SlurmInfo>& slurmInfo)
+{
+	slurmInfo_ = slurmInfo;
+	for(int dep1 = 0; dep1!= slurmInfo.size(); dep1++) {
+		auto slurmInfoObj = slurmInfo.at(dep1);
+		std::string slurmInfoObjStr = "SlurmInfo." + std::to_string(dep1 + 1);
+		setParameter(slurmInfoObjStr + ".SchedInterval", std::to_string(slurmInfoObj.schedInterval));
+		setParameter(slurmInfoObjStr + ".BackfillInterval", std::to_string(slurmInfoObj.backfillInterval));
+	}
+}
+
+std::string SetSchedulerInfoRequest::getClusterId()const
+{
+	return clusterId_;
+}
+
+void SetSchedulerInfoRequest::setClusterId(const std::string& clusterId)
+{
+	clusterId_ = clusterId;
+	setParameter("ClusterId", clusterId);
+}
+
+std::string SetSchedulerInfoRequest::getAccessKeyId()const
+{
+	return accessKeyId_;
+}
+
+void SetSchedulerInfoRequest::setAccessKeyId(const std::string& accessKeyId)
+{
+	accessKeyId_ = accessKeyId;
+	setParameter("AccessKeyId", accessKeyId);
+}
+
+std::vector<SetSchedulerInfoRequest::Scheduler> SetSchedulerInfoRequest::getScheduler()const
+{
+	return scheduler_;
+}
+
+void SetSchedulerInfoRequest::setScheduler(const std::vector<Scheduler>& scheduler)
+{
+	scheduler_ = scheduler;
+	for(int dep1 = 0; dep1!= scheduler.size(); dep1++) {
+		auto schedulerObj = scheduler.at(dep1);
+		std::string schedulerObjStr = "Scheduler." + std::to_string(dep1 + 1);
+		setParameter(schedulerObjStr + ".SchedName", schedulerObj.schedName);
+	}
+}
+
+std::string SetSchedulerInfoRequest::getRegionId()const
+{
+	return regionId_;
+}
+
+void SetSchedulerInfoRequest::setRegionId(const std::string& regionId)
+{
+	regionId_ = regionId;
+	setParameter("RegionId", regionId);
+}
+
+std::vector<SetSchedulerInfoRequest::PbsInfo> SetSchedulerInfoRequest::getPbsInfo()const
+{
+	return pbsInfo_;
+}
+
+void SetSchedulerInfoRequest::setPbsInfo(const std::vector<PbsInfo>& pbsInfo)
+{
+	pbsInfo_ = pbsInfo;
+	for(int dep1 = 0; dep1!= pbsInfo.size(); dep1++) {
+		auto pbsInfoObj = pbsInfo.at(dep1);
+		std::string pbsInfoObjStr = "PbsInfo." + std::to_string(dep1 + 1);
+		setParameter(pbsInfoObjStr + ".SchedInterval", std::to_string(pbsInfoObj.schedInterval));
+		for(int dep2 = 0; dep2!= pbsInfoObj.resourceLimit.size(); dep2++) {
+			auto resourceLimitObj = pbsInfoObj.resourceLimit.at(dep2);
+			std::string resourceLimitObjStr = pbsInfoObjStr + "ResourceLimit." + std::to_string(dep2 + 1);
+			setParameter(resourceLimitObjStr + ".Nodes", std::to_string(resourceLimitObj.nodes));
+			setParameter(resourceLimitObjStr + ".Mem", resourceLimitObj.mem);
+			setParameter(resourceLimitObjStr + ".Cpus", std::to_string(resourceLimitObj.cpus));
+			setParameter(resourceLimitObjStr + ".User", resourceLimitObj.user);
+			setParameter(resourceLimitObjStr + ".Queue", resourceLimitObj.queue);
+		}
+		for(int dep2 = 0; dep2!= pbsInfoObj.aclLimit.size(); dep2++) {
+			auto aclLimitObj = pbsInfoObj.aclLimit.at(dep2);
+			std::string aclLimitObjStr = pbsInfoObjStr + "AclLimit." + std::to_string(dep2 + 1);
+			setParameter(aclLimitObjStr + ".AclUsers", aclLimitObj.aclUsers);
+			setParameter(aclLimitObjStr + ".Queue", aclLimitObj.queue);
+		}
+		setParameter(pbsInfoObjStr + ".JobHistoryDuration", std::to_string(pbsInfoObj.jobHistoryDuration));
+	}
+}
+

ehpc/src/model/SetJobUserResult.cc → ehpc/src/model/SetSchedulerInfoResult.cc

@@ -14,31 +14,38 @@
  * limitations under the License.
  */
 
-#include <alibabacloud/ehpc/model/SetJobUserResult.h>
+#include <alibabacloud/ehpc/model/SetSchedulerInfoResult.h>
 #include <json/json.h>
 
 using namespace AlibabaCloud::EHPC;
 using namespace AlibabaCloud::EHPC::Model;
 
-SetJobUserResult::SetJobUserResult() :
+SetSchedulerInfoResult::SetSchedulerInfoResult() :
 	ServiceResult()
 {}
 
-SetJobUserResult::SetJobUserResult(const std::string &payload) :
+SetSchedulerInfoResult::SetSchedulerInfoResult(const std::string &payload) :
 	ServiceResult()
 {
 	parse(payload);
 }
 
-SetJobUserResult::~SetJobUserResult()
+SetSchedulerInfoResult::~SetSchedulerInfoResult()
 {}
 
-void SetJobUserResult::parse(const std::string &payload)
+void SetSchedulerInfoResult::parse(const std::string &payload)
 {
 	Json::Reader reader;
 	Json::Value value;
 	reader.parse(payload, value);
 	setRequestId(value["RequestId"].asString());
+	if(!value["Message"].isNull())
+		message_ = value["Message"].asString();
 
 }
 
+std::string SetSchedulerInfoResult::getMessage()const
+{
+	return message_;
+}
+

ehpc/src/model/UnbindAccountToClusterUserRequest.cc

@@ -1,73 +0,0 @@
-/*
- * 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/UnbindAccountToClusterUserRequest.h>
-
-using AlibabaCloud::EHPC::Model::UnbindAccountToClusterUserRequest;
-
-UnbindAccountToClusterUserRequest::UnbindAccountToClusterUserRequest() :
-	RpcServiceRequest("ehpc", "2018-04-12", "UnbindAccountToClusterUser")
-{
-	setMethod(HttpRequest::Method::Get);
-}
-
-UnbindAccountToClusterUserRequest::~UnbindAccountToClusterUserRequest()
-{}
-
-std::string UnbindAccountToClusterUserRequest::getClusterId()const
-{
-	return clusterId_;
-}
-
-void UnbindAccountToClusterUserRequest::setClusterId(const std::string& clusterId)
-{
-	clusterId_ = clusterId;
-	setParameter("ClusterId", clusterId);
-}
-
-std::string UnbindAccountToClusterUserRequest::getAccessKeyId()const
-{
-	return accessKeyId_;
-}
-
-void UnbindAccountToClusterUserRequest::setAccessKeyId(const std::string& accessKeyId)
-{
-	accessKeyId_ = accessKeyId;
-	setParameter("AccessKeyId", accessKeyId);
-}
-
-std::string UnbindAccountToClusterUserRequest::getAccountUid()const
-{
-	return accountUid_;
-}
-
-void UnbindAccountToClusterUserRequest::setAccountUid(const std::string& accountUid)
-{
-	accountUid_ = accountUid;
-	setParameter("AccountUid", accountUid);
-}
-
-std::string UnbindAccountToClusterUserRequest::getUserName()const
-{
-	return userName_;
-}
-
-void UnbindAccountToClusterUserRequest::setUserName(const std::string& userName)
-{
-	userName_ = userName;
-	setParameter("UserName", userName);
-}
-