EHPC SDK Auto Released By qianzheng.llc,Version：1.36.0

Signed-off-by: haowei.yao <haowei.yao@alibaba-inc.com>

CHANGELOG

@@ -1,3 +1,8 @@
+2019-04-10 Version: 1.36.0
+1, New APIs for visual service (VNC).
+2, New APIs for software management.
+3, New APIs for CPFS filesystem.
+
 2019-04-09 Version: 1.35.9
 1, support service account management networkInterface function.
 

VERSION

@@ -1 +1 @@
-1.35.9
+1.36.0

ehpc/CMakeLists.txt

@@ -21,6 +21,8 @@ set(ehpc_public_header
 	include/alibabacloud/ehpc/EHPCExport.h )
 
 set(ehpc_public_header_model 
+	include/alibabacloud/ehpc/model/DescribeJobRequest.h
+	include/alibabacloud/ehpc/model/DescribeJobResult.h
 	include/alibabacloud/ehpc/model/DeleteImageRequest.h
 	include/alibabacloud/ehpc/model/DeleteImageResult.h
 	include/alibabacloud/ehpc/model/DeleteUsersRequest.h
@@ -37,48 +39,54 @@ set(ehpc_public_header_model
 	include/alibabacloud/ehpc/model/DescribeContainerAppResult.h
 	include/alibabacloud/ehpc/model/ListCurrentClientVersionRequest.h
 	include/alibabacloud/ehpc/model/ListCurrentClientVersionResult.h
+	include/alibabacloud/ehpc/model/UpdateClusterVolumesRequest.h
+	include/alibabacloud/ehpc/model/UpdateClusterVolumesResult.h
+	include/alibabacloud/ehpc/model/ListNodesByQueueRequest.h
+	include/alibabacloud/ehpc/model/ListNodesByQueueResult.h
 	include/alibabacloud/ehpc/model/ModifyContainerAppAttributesRequest.h
 	include/alibabacloud/ehpc/model/ModifyContainerAppAttributesResult.h
-	include/alibabacloud/ehpc/model/SetAutoScaleConfigRequest.h
-	include/alibabacloud/ehpc/model/SetAutoScaleConfigResult.h
 	include/alibabacloud/ehpc/model/ListInvocationResultsRequest.h
 	include/alibabacloud/ehpc/model/ListInvocationResultsResult.h
-	include/alibabacloud/ehpc/model/AddNodesRequest.h
-	include/alibabacloud/ehpc/model/AddNodesResult.h
+	include/alibabacloud/ehpc/model/SetAutoScaleConfigRequest.h
+	include/alibabacloud/ehpc/model/SetAutoScaleConfigResult.h
 	include/alibabacloud/ehpc/model/ListSoftwaresRequest.h
 	include/alibabacloud/ehpc/model/ListSoftwaresResult.h
+	include/alibabacloud/ehpc/model/AddNodesRequest.h
+	include/alibabacloud/ehpc/model/AddNodesResult.h
 	include/alibabacloud/ehpc/model/StopJobsRequest.h
 	include/alibabacloud/ehpc/model/StopJobsResult.h
 	include/alibabacloud/ehpc/model/StartNodesRequest.h
 	include/alibabacloud/ehpc/model/StartNodesResult.h
 	include/alibabacloud/ehpc/model/GetCloudMetricProfilingRequest.h
 	include/alibabacloud/ehpc/model/GetCloudMetricProfilingResult.h
-	include/alibabacloud/ehpc/model/DescribeImagePriceRequest.h
-	include/alibabacloud/ehpc/model/DescribeImagePriceResult.h
 	include/alibabacloud/ehpc/model/GetAutoScaleConfigRequest.h
 	include/alibabacloud/ehpc/model/GetAutoScaleConfigResult.h
+	include/alibabacloud/ehpc/model/DescribeImagePriceRequest.h
+	include/alibabacloud/ehpc/model/DescribeImagePriceResult.h
 	include/alibabacloud/ehpc/model/ListNodesRequest.h
 	include/alibabacloud/ehpc/model/ListNodesResult.h
 	include/alibabacloud/ehpc/model/ModifyUserGroupsRequest.h
 	include/alibabacloud/ehpc/model/ModifyUserGroupsResult.h
 	include/alibabacloud/ehpc/model/StartClusterRequest.h
 	include/alibabacloud/ehpc/model/StartClusterResult.h
+	include/alibabacloud/ehpc/model/SetQueueRequest.h
+	include/alibabacloud/ehpc/model/SetQueueResult.h
 	include/alibabacloud/ehpc/model/ListCommandsRequest.h
 	include/alibabacloud/ehpc/model/ListCommandsResult.h
 	include/alibabacloud/ehpc/model/ListCustomImagesRequest.h
 	include/alibabacloud/ehpc/model/ListCustomImagesResult.h
 	include/alibabacloud/ehpc/model/InvokeShellCommandRequest.h
 	include/alibabacloud/ehpc/model/InvokeShellCommandResult.h
+	include/alibabacloud/ehpc/model/ListJobTemplatesRequest.h
+	include/alibabacloud/ehpc/model/ListJobTemplatesResult.h
 	include/alibabacloud/ehpc/model/ListFileSystemWithMountTargetsRequest.h
 	include/alibabacloud/ehpc/model/ListFileSystemWithMountTargetsResult.h
 	include/alibabacloud/ehpc/model/AddUsersRequest.h
 	include/alibabacloud/ehpc/model/AddUsersResult.h
-	include/alibabacloud/ehpc/model/ListJobTemplatesRequest.h
-	include/alibabacloud/ehpc/model/ListJobTemplatesResult.h
-	include/alibabacloud/ehpc/model/ModifyClusterAttributesRequest.h
-	include/alibabacloud/ehpc/model/ModifyClusterAttributesResult.h
 	include/alibabacloud/ehpc/model/DescribeImageGatewayConfigRequest.h
 	include/alibabacloud/ehpc/model/DescribeImageGatewayConfigResult.h
+	include/alibabacloud/ehpc/model/ModifyClusterAttributesRequest.h
+	include/alibabacloud/ehpc/model/ModifyClusterAttributesResult.h
 	include/alibabacloud/ehpc/model/DeleteJobTemplatesRequest.h
 	include/alibabacloud/ehpc/model/DeleteJobTemplatesResult.h
 	include/alibabacloud/ehpc/model/StopClusterRequest.h
@@ -87,12 +95,14 @@ set(ehpc_public_header_model
 	include/alibabacloud/ehpc/model/ListNodesNoPagingResult.h
 	include/alibabacloud/ehpc/model/GetCloudMetricLogsRequest.h
 	include/alibabacloud/ehpc/model/GetCloudMetricLogsResult.h
-	include/alibabacloud/ehpc/model/GetHybridClusterConfigRequest.h
-	include/alibabacloud/ehpc/model/GetHybridClusterConfigResult.h
 	include/alibabacloud/ehpc/model/CreateJobTemplateRequest.h
 	include/alibabacloud/ehpc/model/CreateJobTemplateResult.h
+	include/alibabacloud/ehpc/model/GetHybridClusterConfigRequest.h
+	include/alibabacloud/ehpc/model/GetHybridClusterConfigResult.h
 	include/alibabacloud/ehpc/model/ResetNodesRequest.h
 	include/alibabacloud/ehpc/model/ResetNodesResult.h
+	include/alibabacloud/ehpc/model/UninstallSoftwareRequest.h
+	include/alibabacloud/ehpc/model/UninstallSoftwareResult.h
 	include/alibabacloud/ehpc/model/CreateHybridClusterRequest.h
 	include/alibabacloud/ehpc/model/CreateHybridClusterResult.h
 	include/alibabacloud/ehpc/model/ListContainerImagesRequest.h
@@ -101,16 +111,28 @@ set(ehpc_public_header_model
 	include/alibabacloud/ehpc/model/DeleteJobsResult.h
 	include/alibabacloud/ehpc/model/DeleteNodesRequest.h
 	include/alibabacloud/ehpc/model/DeleteNodesResult.h
+	include/alibabacloud/ehpc/model/StopVisualServiceRequest.h
+	include/alibabacloud/ehpc/model/StopVisualServiceResult.h
 	include/alibabacloud/ehpc/model/ListJobsRequest.h
 	include/alibabacloud/ehpc/model/ListJobsResult.h
 	include/alibabacloud/ehpc/model/CreateClusterRequest.h
 	include/alibabacloud/ehpc/model/CreateClusterResult.h
-	include/alibabacloud/ehpc/model/DescribeImageRequest.h
-	include/alibabacloud/ehpc/model/DescribeImageResult.h
 	include/alibabacloud/ehpc/model/ModifyUserPasswordsRequest.h
 	include/alibabacloud/ehpc/model/ModifyUserPasswordsResult.h
+	include/alibabacloud/ehpc/model/DescribeImageRequest.h
+	include/alibabacloud/ehpc/model/DescribeImageResult.h
+	include/alibabacloud/ehpc/model/DeleteQueueRequest.h
+	include/alibabacloud/ehpc/model/DeleteQueueResult.h
+	include/alibabacloud/ehpc/model/ListCpfsFileSystemsRequest.h
+	include/alibabacloud/ehpc/model/ListCpfsFileSystemsResult.h
+	include/alibabacloud/ehpc/model/ListInstalledSoftwareRequest.h
+	include/alibabacloud/ehpc/model/ListInstalledSoftwareResult.h
 	include/alibabacloud/ehpc/model/UpgradeClientRequest.h
 	include/alibabacloud/ehpc/model/UpgradeClientResult.h
+	include/alibabacloud/ehpc/model/ListAvailableFileSystemTypesRequest.h
+	include/alibabacloud/ehpc/model/ListAvailableFileSystemTypesResult.h
+	include/alibabacloud/ehpc/model/ListClustersMetaRequest.h
+	include/alibabacloud/ehpc/model/ListClustersMetaResult.h
 	include/alibabacloud/ehpc/model/DeleteClusterRequest.h
 	include/alibabacloud/ehpc/model/DeleteClusterResult.h
 	include/alibabacloud/ehpc/model/ListImagesRequest.h
@@ -127,20 +149,30 @@ set(ehpc_public_header_model
 	include/alibabacloud/ehpc/model/ListContainerAppsResult.h
 	include/alibabacloud/ehpc/model/ListQueuesRequest.h
 	include/alibabacloud/ehpc/model/ListQueuesResult.h
+	include/alibabacloud/ehpc/model/CreateJobFileRequest.h
+	include/alibabacloud/ehpc/model/CreateJobFileResult.h
 	include/alibabacloud/ehpc/model/ListCloudMetricProfilingsRequest.h
 	include/alibabacloud/ehpc/model/ListCloudMetricProfilingsResult.h
+	include/alibabacloud/ehpc/model/GetClusterVolumesRequest.h
+	include/alibabacloud/ehpc/model/GetClusterVolumesResult.h
 	include/alibabacloud/ehpc/model/SetJobUserRequest.h
 	include/alibabacloud/ehpc/model/SetJobUserResult.h
 	include/alibabacloud/ehpc/model/ListClustersRequest.h
 	include/alibabacloud/ehpc/model/ListClustersResult.h
 	include/alibabacloud/ehpc/model/SubmitJobRequest.h
 	include/alibabacloud/ehpc/model/SubmitJobResult.h
+	include/alibabacloud/ehpc/model/GetAccountingReportRequest.h
+	include/alibabacloud/ehpc/model/GetAccountingReportResult.h
 	include/alibabacloud/ehpc/model/ListRegionsRequest.h
 	include/alibabacloud/ehpc/model/ListRegionsResult.h
 	include/alibabacloud/ehpc/model/DescribeAutoScaleConfigRequest.h
 	include/alibabacloud/ehpc/model/DescribeAutoScaleConfigResult.h
+	include/alibabacloud/ehpc/model/GetVisualServiceStatusRequest.h
+	include/alibabacloud/ehpc/model/GetVisualServiceStatusResult.h
 	include/alibabacloud/ehpc/model/RunCloudMetricProfilingRequest.h
 	include/alibabacloud/ehpc/model/RunCloudMetricProfilingResult.h
+	include/alibabacloud/ehpc/model/StartVisualServiceRequest.h
+	include/alibabacloud/ehpc/model/StartVisualServiceResult.h
 	include/alibabacloud/ehpc/model/DescribePriceRequest.h
 	include/alibabacloud/ehpc/model/DescribePriceResult.h
 	include/alibabacloud/ehpc/model/RerunJobsRequest.h
@@ -149,19 +181,27 @@ set(ehpc_public_header_model
 	include/alibabacloud/ehpc/model/EditJobTemplateResult.h
 	include/alibabacloud/ehpc/model/AddLocalNodesRequest.h
 	include/alibabacloud/ehpc/model/AddLocalNodesResult.h
+	include/alibabacloud/ehpc/model/ModifyVisualServicePasswdRequest.h
+	include/alibabacloud/ehpc/model/ModifyVisualServicePasswdResult.h
 	include/alibabacloud/ehpc/model/ListPreferredEcsTypesRequest.h
 	include/alibabacloud/ehpc/model/ListPreferredEcsTypesResult.h
 	include/alibabacloud/ehpc/model/AddContainerAppRequest.h
 	include/alibabacloud/ehpc/model/AddContainerAppResult.h
+	include/alibabacloud/ehpc/model/InstallSoftwareRequest.h
+	include/alibabacloud/ehpc/model/InstallSoftwareResult.h
 	include/alibabacloud/ehpc/model/ListClusterLogsRequest.h
 	include/alibabacloud/ehpc/model/ListClusterLogsResult.h
 	include/alibabacloud/ehpc/model/RecoverClusterRequest.h
 	include/alibabacloud/ehpc/model/RecoverClusterResult.h
 	include/alibabacloud/ehpc/model/ListAvailableEcsTypesRequest.h
-	include/alibabacloud/ehpc/model/ListAvailableEcsTypesResult.h )
+	include/alibabacloud/ehpc/model/ListAvailableEcsTypesResult.h
+	include/alibabacloud/ehpc/model/AddQueueRequest.h
+	include/alibabacloud/ehpc/model/AddQueueResult.h )
 
 set(ehpc_src 
 	src/EHPCClient.cc
+	src/model/DescribeJobRequest.cc
+	src/model/DescribeJobResult.cc
 	src/model/DeleteImageRequest.cc
 	src/model/DeleteImageResult.cc
 	src/model/DeleteUsersRequest.cc
@@ -178,48 +218,54 @@ set(ehpc_src
 	src/model/DescribeContainerAppResult.cc
 	src/model/ListCurrentClientVersionRequest.cc
 	src/model/ListCurrentClientVersionResult.cc
+	src/model/UpdateClusterVolumesRequest.cc
+	src/model/UpdateClusterVolumesResult.cc
+	src/model/ListNodesByQueueRequest.cc
+	src/model/ListNodesByQueueResult.cc
 	src/model/ModifyContainerAppAttributesRequest.cc
 	src/model/ModifyContainerAppAttributesResult.cc
-	src/model/SetAutoScaleConfigRequest.cc
-	src/model/SetAutoScaleConfigResult.cc
 	src/model/ListInvocationResultsRequest.cc
 	src/model/ListInvocationResultsResult.cc
-	src/model/AddNodesRequest.cc
-	src/model/AddNodesResult.cc
+	src/model/SetAutoScaleConfigRequest.cc
+	src/model/SetAutoScaleConfigResult.cc
 	src/model/ListSoftwaresRequest.cc
 	src/model/ListSoftwaresResult.cc
+	src/model/AddNodesRequest.cc
+	src/model/AddNodesResult.cc
 	src/model/StopJobsRequest.cc
 	src/model/StopJobsResult.cc
 	src/model/StartNodesRequest.cc
 	src/model/StartNodesResult.cc
 	src/model/GetCloudMetricProfilingRequest.cc
 	src/model/GetCloudMetricProfilingResult.cc
-	src/model/DescribeImagePriceRequest.cc
-	src/model/DescribeImagePriceResult.cc
 	src/model/GetAutoScaleConfigRequest.cc
 	src/model/GetAutoScaleConfigResult.cc
+	src/model/DescribeImagePriceRequest.cc
+	src/model/DescribeImagePriceResult.cc
 	src/model/ListNodesRequest.cc
 	src/model/ListNodesResult.cc
 	src/model/ModifyUserGroupsRequest.cc
 	src/model/ModifyUserGroupsResult.cc
 	src/model/StartClusterRequest.cc
 	src/model/StartClusterResult.cc
+	src/model/SetQueueRequest.cc
+	src/model/SetQueueResult.cc
 	src/model/ListCommandsRequest.cc
 	src/model/ListCommandsResult.cc
 	src/model/ListCustomImagesRequest.cc
 	src/model/ListCustomImagesResult.cc
 	src/model/InvokeShellCommandRequest.cc
 	src/model/InvokeShellCommandResult.cc
+	src/model/ListJobTemplatesRequest.cc
+	src/model/ListJobTemplatesResult.cc
 	src/model/ListFileSystemWithMountTargetsRequest.cc
 	src/model/ListFileSystemWithMountTargetsResult.cc
 	src/model/AddUsersRequest.cc
 	src/model/AddUsersResult.cc
-	src/model/ListJobTemplatesRequest.cc
-	src/model/ListJobTemplatesResult.cc
-	src/model/ModifyClusterAttributesRequest.cc
-	src/model/ModifyClusterAttributesResult.cc
 	src/model/DescribeImageGatewayConfigRequest.cc
 	src/model/DescribeImageGatewayConfigResult.cc
+	src/model/ModifyClusterAttributesRequest.cc
+	src/model/ModifyClusterAttributesResult.cc
 	src/model/DeleteJobTemplatesRequest.cc
 	src/model/DeleteJobTemplatesResult.cc
 	src/model/StopClusterRequest.cc
@@ -228,12 +274,14 @@ set(ehpc_src
 	src/model/ListNodesNoPagingResult.cc
 	src/model/GetCloudMetricLogsRequest.cc
 	src/model/GetCloudMetricLogsResult.cc
-	src/model/GetHybridClusterConfigRequest.cc
-	src/model/GetHybridClusterConfigResult.cc
 	src/model/CreateJobTemplateRequest.cc
 	src/model/CreateJobTemplateResult.cc
+	src/model/GetHybridClusterConfigRequest.cc
+	src/model/GetHybridClusterConfigResult.cc
 	src/model/ResetNodesRequest.cc
 	src/model/ResetNodesResult.cc
+	src/model/UninstallSoftwareRequest.cc
+	src/model/UninstallSoftwareResult.cc
 	src/model/CreateHybridClusterRequest.cc
 	src/model/CreateHybridClusterResult.cc
 	src/model/ListContainerImagesRequest.cc
@@ -242,16 +290,28 @@ set(ehpc_src
 	src/model/DeleteJobsResult.cc
 	src/model/DeleteNodesRequest.cc
 	src/model/DeleteNodesResult.cc
+	src/model/StopVisualServiceRequest.cc
+	src/model/StopVisualServiceResult.cc
 	src/model/ListJobsRequest.cc
 	src/model/ListJobsResult.cc
 	src/model/CreateClusterRequest.cc
 	src/model/CreateClusterResult.cc
-	src/model/DescribeImageRequest.cc
-	src/model/DescribeImageResult.cc
 	src/model/ModifyUserPasswordsRequest.cc
 	src/model/ModifyUserPasswordsResult.cc
+	src/model/DescribeImageRequest.cc
+	src/model/DescribeImageResult.cc
+	src/model/DeleteQueueRequest.cc
+	src/model/DeleteQueueResult.cc
+	src/model/ListCpfsFileSystemsRequest.cc
+	src/model/ListCpfsFileSystemsResult.cc
+	src/model/ListInstalledSoftwareRequest.cc
+	src/model/ListInstalledSoftwareResult.cc
 	src/model/UpgradeClientRequest.cc
 	src/model/UpgradeClientResult.cc
+	src/model/ListAvailableFileSystemTypesRequest.cc
+	src/model/ListAvailableFileSystemTypesResult.cc
+	src/model/ListClustersMetaRequest.cc
+	src/model/ListClustersMetaResult.cc
 	src/model/DeleteClusterRequest.cc
 	src/model/DeleteClusterResult.cc
 	src/model/ListImagesRequest.cc
@@ -268,20 +328,30 @@ set(ehpc_src
 	src/model/ListContainerAppsResult.cc
 	src/model/ListQueuesRequest.cc
 	src/model/ListQueuesResult.cc
+	src/model/CreateJobFileRequest.cc
+	src/model/CreateJobFileResult.cc
 	src/model/ListCloudMetricProfilingsRequest.cc
 	src/model/ListCloudMetricProfilingsResult.cc
+	src/model/GetClusterVolumesRequest.cc
+	src/model/GetClusterVolumesResult.cc
 	src/model/SetJobUserRequest.cc
 	src/model/SetJobUserResult.cc
 	src/model/ListClustersRequest.cc
 	src/model/ListClustersResult.cc
 	src/model/SubmitJobRequest.cc
 	src/model/SubmitJobResult.cc
+	src/model/GetAccountingReportRequest.cc
+	src/model/GetAccountingReportResult.cc
 	src/model/ListRegionsRequest.cc
 	src/model/ListRegionsResult.cc
 	src/model/DescribeAutoScaleConfigRequest.cc
 	src/model/DescribeAutoScaleConfigResult.cc
+	src/model/GetVisualServiceStatusRequest.cc
+	src/model/GetVisualServiceStatusResult.cc
 	src/model/RunCloudMetricProfilingRequest.cc
 	src/model/RunCloudMetricProfilingResult.cc
+	src/model/StartVisualServiceRequest.cc
+	src/model/StartVisualServiceResult.cc
 	src/model/DescribePriceRequest.cc
 	src/model/DescribePriceResult.cc
 	src/model/RerunJobsRequest.cc
@@ -290,16 +360,22 @@ set(ehpc_src
 	src/model/EditJobTemplateResult.cc
 	src/model/AddLocalNodesRequest.cc
 	src/model/AddLocalNodesResult.cc
+	src/model/ModifyVisualServicePasswdRequest.cc
+	src/model/ModifyVisualServicePasswdResult.cc
 	src/model/ListPreferredEcsTypesRequest.cc
 	src/model/ListPreferredEcsTypesResult.cc
 	src/model/AddContainerAppRequest.cc
 	src/model/AddContainerAppResult.cc
+	src/model/InstallSoftwareRequest.cc
+	src/model/InstallSoftwareResult.cc
 	src/model/ListClusterLogsRequest.cc
 	src/model/ListClusterLogsResult.cc
 	src/model/RecoverClusterRequest.cc
 	src/model/RecoverClusterResult.cc
 	src/model/ListAvailableEcsTypesRequest.cc
-	src/model/ListAvailableEcsTypesResult.cc )
+	src/model/ListAvailableEcsTypesResult.cc
+	src/model/AddQueueRequest.cc
+	src/model/AddQueueResult.cc )
 
 add_library(ehpc ${LIB_TYPE}
 	${ehpc_public_header}

ehpc/include/alibabacloud/ehpc/EHPCClient.h

@@ -22,6 +22,8 @@
 #include <alibabacloud/core/EndpointProvider.h>
 #include <alibabacloud/core/RpcServiceClient.h>
 #include "EHPCExport.h"
+#include "model/DescribeJobRequest.h"
+#include "model/DescribeJobResult.h"
 #include "model/DeleteImageRequest.h"
 #include "model/DeleteImageResult.h"
 #include "model/DeleteUsersRequest.h"
@@ -38,48 +40,54 @@
 #include "model/DescribeContainerAppResult.h"
 #include "model/ListCurrentClientVersionRequest.h"
 #include "model/ListCurrentClientVersionResult.h"
+#include "model/UpdateClusterVolumesRequest.h"
+#include "model/UpdateClusterVolumesResult.h"
+#include "model/ListNodesByQueueRequest.h"
+#include "model/ListNodesByQueueResult.h"
 #include "model/ModifyContainerAppAttributesRequest.h"
 #include "model/ModifyContainerAppAttributesResult.h"
-#include "model/SetAutoScaleConfigRequest.h"
-#include "model/SetAutoScaleConfigResult.h"
 #include "model/ListInvocationResultsRequest.h"
 #include "model/ListInvocationResultsResult.h"
-#include "model/AddNodesRequest.h"
-#include "model/AddNodesResult.h"
+#include "model/SetAutoScaleConfigRequest.h"
+#include "model/SetAutoScaleConfigResult.h"
 #include "model/ListSoftwaresRequest.h"
 #include "model/ListSoftwaresResult.h"
+#include "model/AddNodesRequest.h"
+#include "model/AddNodesResult.h"
 #include "model/StopJobsRequest.h"
 #include "model/StopJobsResult.h"
 #include "model/StartNodesRequest.h"
 #include "model/StartNodesResult.h"
 #include "model/GetCloudMetricProfilingRequest.h"
 #include "model/GetCloudMetricProfilingResult.h"
-#include "model/DescribeImagePriceRequest.h"
-#include "model/DescribeImagePriceResult.h"
 #include "model/GetAutoScaleConfigRequest.h"
 #include "model/GetAutoScaleConfigResult.h"
+#include "model/DescribeImagePriceRequest.h"
+#include "model/DescribeImagePriceResult.h"
 #include "model/ListNodesRequest.h"
 #include "model/ListNodesResult.h"
 #include "model/ModifyUserGroupsRequest.h"
 #include "model/ModifyUserGroupsResult.h"
 #include "model/StartClusterRequest.h"
 #include "model/StartClusterResult.h"
+#include "model/SetQueueRequest.h"
+#include "model/SetQueueResult.h"
 #include "model/ListCommandsRequest.h"
 #include "model/ListCommandsResult.h"
 #include "model/ListCustomImagesRequest.h"
 #include "model/ListCustomImagesResult.h"
 #include "model/InvokeShellCommandRequest.h"
 #include "model/InvokeShellCommandResult.h"
+#include "model/ListJobTemplatesRequest.h"
+#include "model/ListJobTemplatesResult.h"
 #include "model/ListFileSystemWithMountTargetsRequest.h"
 #include "model/ListFileSystemWithMountTargetsResult.h"
 #include "model/AddUsersRequest.h"
 #include "model/AddUsersResult.h"
-#include "model/ListJobTemplatesRequest.h"
-#include "model/ListJobTemplatesResult.h"
-#include "model/ModifyClusterAttributesRequest.h"
-#include "model/ModifyClusterAttributesResult.h"
 #include "model/DescribeImageGatewayConfigRequest.h"
 #include "model/DescribeImageGatewayConfigResult.h"
+#include "model/ModifyClusterAttributesRequest.h"
+#include "model/ModifyClusterAttributesResult.h"
 #include "model/DeleteJobTemplatesRequest.h"
 #include "model/DeleteJobTemplatesResult.h"
 #include "model/StopClusterRequest.h"
@@ -88,12 +96,14 @@
 #include "model/ListNodesNoPagingResult.h"
 #include "model/GetCloudMetricLogsRequest.h"
 #include "model/GetCloudMetricLogsResult.h"
-#include "model/GetHybridClusterConfigRequest.h"
-#include "model/GetHybridClusterConfigResult.h"
 #include "model/CreateJobTemplateRequest.h"
 #include "model/CreateJobTemplateResult.h"
+#include "model/GetHybridClusterConfigRequest.h"
+#include "model/GetHybridClusterConfigResult.h"
 #include "model/ResetNodesRequest.h"
 #include "model/ResetNodesResult.h"
+#include "model/UninstallSoftwareRequest.h"
+#include "model/UninstallSoftwareResult.h"
 #include "model/CreateHybridClusterRequest.h"
 #include "model/CreateHybridClusterResult.h"
 #include "model/ListContainerImagesRequest.h"
@@ -102,16 +112,28 @@
 #include "model/DeleteJobsResult.h"
 #include "model/DeleteNodesRequest.h"
 #include "model/DeleteNodesResult.h"
+#include "model/StopVisualServiceRequest.h"
+#include "model/StopVisualServiceResult.h"
 #include "model/ListJobsRequest.h"
 #include "model/ListJobsResult.h"
 #include "model/CreateClusterRequest.h"
 #include "model/CreateClusterResult.h"
-#include "model/DescribeImageRequest.h"
-#include "model/DescribeImageResult.h"
 #include "model/ModifyUserPasswordsRequest.h"
 #include "model/ModifyUserPasswordsResult.h"
+#include "model/DescribeImageRequest.h"
+#include "model/DescribeImageResult.h"
+#include "model/DeleteQueueRequest.h"
+#include "model/DeleteQueueResult.h"
+#include "model/ListCpfsFileSystemsRequest.h"
+#include "model/ListCpfsFileSystemsResult.h"
+#include "model/ListInstalledSoftwareRequest.h"
+#include "model/ListInstalledSoftwareResult.h"
 #include "model/UpgradeClientRequest.h"
 #include "model/UpgradeClientResult.h"
+#include "model/ListAvailableFileSystemTypesRequest.h"
+#include "model/ListAvailableFileSystemTypesResult.h"
+#include "model/ListClustersMetaRequest.h"
+#include "model/ListClustersMetaResult.h"
 #include "model/DeleteClusterRequest.h"
 #include "model/DeleteClusterResult.h"
 #include "model/ListImagesRequest.h"
@@ -128,20 +150,30 @@
 #include "model/ListContainerAppsResult.h"
 #include "model/ListQueuesRequest.h"
 #include "model/ListQueuesResult.h"
+#include "model/CreateJobFileRequest.h"
+#include "model/CreateJobFileResult.h"
 #include "model/ListCloudMetricProfilingsRequest.h"
 #include "model/ListCloudMetricProfilingsResult.h"
+#include "model/GetClusterVolumesRequest.h"
+#include "model/GetClusterVolumesResult.h"
 #include "model/SetJobUserRequest.h"
 #include "model/SetJobUserResult.h"
 #include "model/ListClustersRequest.h"
 #include "model/ListClustersResult.h"
 #include "model/SubmitJobRequest.h"
 #include "model/SubmitJobResult.h"
+#include "model/GetAccountingReportRequest.h"
+#include "model/GetAccountingReportResult.h"
 #include "model/ListRegionsRequest.h"
 #include "model/ListRegionsResult.h"
 #include "model/DescribeAutoScaleConfigRequest.h"
 #include "model/DescribeAutoScaleConfigResult.h"
+#include "model/GetVisualServiceStatusRequest.h"
+#include "model/GetVisualServiceStatusResult.h"
 #include "model/RunCloudMetricProfilingRequest.h"
 #include "model/RunCloudMetricProfilingResult.h"
+#include "model/StartVisualServiceRequest.h"
+#include "model/StartVisualServiceResult.h"
 #include "model/DescribePriceRequest.h"
 #include "model/DescribePriceResult.h"
 #include "model/RerunJobsRequest.h"
@@ -150,16 +182,22 @@
 #include "model/EditJobTemplateResult.h"
 #include "model/AddLocalNodesRequest.h"
 #include "model/AddLocalNodesResult.h"
+#include "model/ModifyVisualServicePasswdRequest.h"
+#include "model/ModifyVisualServicePasswdResult.h"
 #include "model/ListPreferredEcsTypesRequest.h"
 #include "model/ListPreferredEcsTypesResult.h"
 #include "model/AddContainerAppRequest.h"
 #include "model/AddContainerAppResult.h"
+#include "model/InstallSoftwareRequest.h"
+#include "model/InstallSoftwareResult.h"
 #include "model/ListClusterLogsRequest.h"
 #include "model/ListClusterLogsResult.h"
 #include "model/RecoverClusterRequest.h"
 #include "model/RecoverClusterResult.h"
 #include "model/ListAvailableEcsTypesRequest.h"
 #include "model/ListAvailableEcsTypesResult.h"
+#include "model/AddQueueRequest.h"
+#include "model/AddQueueResult.h"
 
 
 namespace AlibabaCloud
@@ -169,6 +207,9 @@ namespace AlibabaCloud
 		class ALIBABACLOUD_EHPC_EXPORT EHPCClient : public RpcServiceClient
 		{
 		public:
+			typedef Outcome<Error, Model::DescribeJobResult> DescribeJobOutcome;
+			typedef std::future<DescribeJobOutcome> DescribeJobOutcomeCallable;
+			typedef std::function<void(const EHPCClient*, const Model::DescribeJobRequest&, const DescribeJobOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeJobAsyncHandler;
 			typedef Outcome<Error, Model::DeleteImageResult> DeleteImageOutcome;
 			typedef std::future<DeleteImageOutcome> DeleteImageOutcomeCallable;
 			typedef std::function<void(const EHPCClient*, const Model::DeleteImageRequest&, const DeleteImageOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteImageAsyncHandler;
@@ -193,21 +234,27 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::ListCurrentClientVersionResult> ListCurrentClientVersionOutcome;
 			typedef std::future<ListCurrentClientVersionOutcome> ListCurrentClientVersionOutcomeCallable;
 			typedef std::function<void(const EHPCClient*, const Model::ListCurrentClientVersionRequest&, const ListCurrentClientVersionOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListCurrentClientVersionAsyncHandler;
+			typedef Outcome<Error, Model::UpdateClusterVolumesResult> UpdateClusterVolumesOutcome;
+			typedef std::future<UpdateClusterVolumesOutcome> UpdateClusterVolumesOutcomeCallable;
+			typedef std::function<void(const EHPCClient*, const Model::UpdateClusterVolumesRequest&, const UpdateClusterVolumesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> UpdateClusterVolumesAsyncHandler;
+			typedef Outcome<Error, Model::ListNodesByQueueResult> ListNodesByQueueOutcome;
+			typedef std::future<ListNodesByQueueOutcome> ListNodesByQueueOutcomeCallable;
+			typedef std::function<void(const EHPCClient*, const Model::ListNodesByQueueRequest&, const ListNodesByQueueOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListNodesByQueueAsyncHandler;
 			typedef Outcome<Error, Model::ModifyContainerAppAttributesResult> ModifyContainerAppAttributesOutcome;
 			typedef std::future<ModifyContainerAppAttributesOutcome> ModifyContainerAppAttributesOutcomeCallable;
 			typedef std::function<void(const EHPCClient*, const Model::ModifyContainerAppAttributesRequest&, const ModifyContainerAppAttributesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ModifyContainerAppAttributesAsyncHandler;
-			typedef Outcome<Error, Model::SetAutoScaleConfigResult> SetAutoScaleConfigOutcome;
-			typedef std::future<SetAutoScaleConfigOutcome> SetAutoScaleConfigOutcomeCallable;
-			typedef std::function<void(const EHPCClient*, const Model::SetAutoScaleConfigRequest&, const SetAutoScaleConfigOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> SetAutoScaleConfigAsyncHandler;
 			typedef Outcome<Error, Model::ListInvocationResultsResult> ListInvocationResultsOutcome;
 			typedef std::future<ListInvocationResultsOutcome> ListInvocationResultsOutcomeCallable;
 			typedef std::function<void(const EHPCClient*, const Model::ListInvocationResultsRequest&, const ListInvocationResultsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListInvocationResultsAsyncHandler;
-			typedef Outcome<Error, Model::AddNodesResult> AddNodesOutcome;
-			typedef std::future<AddNodesOutcome> AddNodesOutcomeCallable;
-			typedef std::function<void(const EHPCClient*, const Model::AddNodesRequest&, const AddNodesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> AddNodesAsyncHandler;
+			typedef Outcome<Error, Model::SetAutoScaleConfigResult> SetAutoScaleConfigOutcome;
+			typedef std::future<SetAutoScaleConfigOutcome> SetAutoScaleConfigOutcomeCallable;
+			typedef std::function<void(const EHPCClient*, const Model::SetAutoScaleConfigRequest&, const SetAutoScaleConfigOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> SetAutoScaleConfigAsyncHandler;
 			typedef Outcome<Error, Model::ListSoftwaresResult> ListSoftwaresOutcome;
 			typedef std::future<ListSoftwaresOutcome> ListSoftwaresOutcomeCallable;
 			typedef std::function<void(const EHPCClient*, const Model::ListSoftwaresRequest&, const ListSoftwaresOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListSoftwaresAsyncHandler;
+			typedef Outcome<Error, Model::AddNodesResult> AddNodesOutcome;
+			typedef std::future<AddNodesOutcome> AddNodesOutcomeCallable;
+			typedef std::function<void(const EHPCClient*, const Model::AddNodesRequest&, const AddNodesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> AddNodesAsyncHandler;
 			typedef Outcome<Error, Model::StopJobsResult> StopJobsOutcome;
 			typedef std::future<StopJobsOutcome> StopJobsOutcomeCallable;
 			typedef std::function<void(const EHPCClient*, const Model::StopJobsRequest&, const StopJobsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> StopJobsAsyncHandler;
@@ -217,12 +264,12 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::GetCloudMetricProfilingResult> GetCloudMetricProfilingOutcome;
 			typedef std::future<GetCloudMetricProfilingOutcome> GetCloudMetricProfilingOutcomeCallable;
 			typedef std::function<void(const EHPCClient*, const Model::GetCloudMetricProfilingRequest&, const GetCloudMetricProfilingOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetCloudMetricProfilingAsyncHandler;
-			typedef Outcome<Error, Model::DescribeImagePriceResult> DescribeImagePriceOutcome;
-			typedef std::future<DescribeImagePriceOutcome> DescribeImagePriceOutcomeCallable;
-			typedef std::function<void(const EHPCClient*, const Model::DescribeImagePriceRequest&, const DescribeImagePriceOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeImagePriceAsyncHandler;
 			typedef Outcome<Error, Model::GetAutoScaleConfigResult> GetAutoScaleConfigOutcome;
 			typedef std::future<GetAutoScaleConfigOutcome> GetAutoScaleConfigOutcomeCallable;
 			typedef std::function<void(const EHPCClient*, const Model::GetAutoScaleConfigRequest&, const GetAutoScaleConfigOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetAutoScaleConfigAsyncHandler;
+			typedef Outcome<Error, Model::DescribeImagePriceResult> DescribeImagePriceOutcome;
+			typedef std::future<DescribeImagePriceOutcome> DescribeImagePriceOutcomeCallable;
+			typedef std::function<void(const EHPCClient*, const Model::DescribeImagePriceRequest&, const DescribeImagePriceOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeImagePriceAsyncHandler;
 			typedef Outcome<Error, Model::ListNodesResult> ListNodesOutcome;
 			typedef std::future<ListNodesOutcome> ListNodesOutcomeCallable;
 			typedef std::function<void(const EHPCClient*, const Model::ListNodesRequest&, const ListNodesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListNodesAsyncHandler;
@@ -232,6 +279,9 @@ namespace AlibabaCloud
 			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;
+			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::ListCommandsResult> ListCommandsOutcome;
 			typedef std::future<ListCommandsOutcome> ListCommandsOutcomeCallable;
 			typedef std::function<void(const EHPCClient*, const Model::ListCommandsRequest&, const ListCommandsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListCommandsAsyncHandler;
@@ -241,21 +291,21 @@ 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::ListJobTemplatesResult> ListJobTemplatesOutcome;
+			typedef std::future<ListJobTemplatesOutcome> ListJobTemplatesOutcomeCallable;
+			typedef std::function<void(const EHPCClient*, const Model::ListJobTemplatesRequest&, const ListJobTemplatesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListJobTemplatesAsyncHandler;
 			typedef Outcome<Error, Model::ListFileSystemWithMountTargetsResult> ListFileSystemWithMountTargetsOutcome;
 			typedef std::future<ListFileSystemWithMountTargetsOutcome> ListFileSystemWithMountTargetsOutcomeCallable;
 			typedef std::function<void(const EHPCClient*, const Model::ListFileSystemWithMountTargetsRequest&, const ListFileSystemWithMountTargetsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListFileSystemWithMountTargetsAsyncHandler;
 			typedef Outcome<Error, Model::AddUsersResult> AddUsersOutcome;
 			typedef std::future<AddUsersOutcome> AddUsersOutcomeCallable;
 			typedef std::function<void(const EHPCClient*, const Model::AddUsersRequest&, const AddUsersOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> AddUsersAsyncHandler;
-			typedef Outcome<Error, Model::ListJobTemplatesResult> ListJobTemplatesOutcome;
-			typedef std::future<ListJobTemplatesOutcome> ListJobTemplatesOutcomeCallable;
-			typedef std::function<void(const EHPCClient*, const Model::ListJobTemplatesRequest&, const ListJobTemplatesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListJobTemplatesAsyncHandler;
-			typedef Outcome<Error, Model::ModifyClusterAttributesResult> ModifyClusterAttributesOutcome;
-			typedef std::future<ModifyClusterAttributesOutcome> ModifyClusterAttributesOutcomeCallable;
-			typedef std::function<void(const EHPCClient*, const Model::ModifyClusterAttributesRequest&, const ModifyClusterAttributesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ModifyClusterAttributesAsyncHandler;
 			typedef Outcome<Error, Model::DescribeImageGatewayConfigResult> DescribeImageGatewayConfigOutcome;
 			typedef std::future<DescribeImageGatewayConfigOutcome> DescribeImageGatewayConfigOutcomeCallable;
 			typedef std::function<void(const EHPCClient*, const Model::DescribeImageGatewayConfigRequest&, const DescribeImageGatewayConfigOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeImageGatewayConfigAsyncHandler;
+			typedef Outcome<Error, Model::ModifyClusterAttributesResult> ModifyClusterAttributesOutcome;
+			typedef std::future<ModifyClusterAttributesOutcome> ModifyClusterAttributesOutcomeCallable;
+			typedef std::function<void(const EHPCClient*, const Model::ModifyClusterAttributesRequest&, const ModifyClusterAttributesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ModifyClusterAttributesAsyncHandler;
 			typedef Outcome<Error, Model::DeleteJobTemplatesResult> DeleteJobTemplatesOutcome;
 			typedef std::future<DeleteJobTemplatesOutcome> DeleteJobTemplatesOutcomeCallable;
 			typedef std::function<void(const EHPCClient*, const Model::DeleteJobTemplatesRequest&, const DeleteJobTemplatesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteJobTemplatesAsyncHandler;
@@ -268,15 +318,18 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::GetCloudMetricLogsResult> GetCloudMetricLogsOutcome;
 			typedef std::future<GetCloudMetricLogsOutcome> GetCloudMetricLogsOutcomeCallable;
 			typedef std::function<void(const EHPCClient*, const Model::GetCloudMetricLogsRequest&, const GetCloudMetricLogsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetCloudMetricLogsAsyncHandler;
-			typedef Outcome<Error, Model::GetHybridClusterConfigResult> GetHybridClusterConfigOutcome;
-			typedef std::future<GetHybridClusterConfigOutcome> GetHybridClusterConfigOutcomeCallable;
-			typedef std::function<void(const EHPCClient*, const Model::GetHybridClusterConfigRequest&, const GetHybridClusterConfigOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetHybridClusterConfigAsyncHandler;
 			typedef Outcome<Error, Model::CreateJobTemplateResult> CreateJobTemplateOutcome;
 			typedef std::future<CreateJobTemplateOutcome> CreateJobTemplateOutcomeCallable;
 			typedef std::function<void(const EHPCClient*, const Model::CreateJobTemplateRequest&, const CreateJobTemplateOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateJobTemplateAsyncHandler;
+			typedef Outcome<Error, Model::GetHybridClusterConfigResult> GetHybridClusterConfigOutcome;
+			typedef std::future<GetHybridClusterConfigOutcome> GetHybridClusterConfigOutcomeCallable;
+			typedef std::function<void(const EHPCClient*, const Model::GetHybridClusterConfigRequest&, const GetHybridClusterConfigOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetHybridClusterConfigAsyncHandler;
 			typedef Outcome<Error, Model::ResetNodesResult> ResetNodesOutcome;
 			typedef std::future<ResetNodesOutcome> ResetNodesOutcomeCallable;
 			typedef std::function<void(const EHPCClient*, const Model::ResetNodesRequest&, const ResetNodesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ResetNodesAsyncHandler;
+			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;
 			typedef Outcome<Error, Model::CreateHybridClusterResult> CreateHybridClusterOutcome;
 			typedef std::future<CreateHybridClusterOutcome> CreateHybridClusterOutcomeCallable;
 			typedef std::function<void(const EHPCClient*, const Model::CreateHybridClusterRequest&, const CreateHybridClusterOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateHybridClusterAsyncHandler;
@@ -289,21 +342,39 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::DeleteNodesResult> DeleteNodesOutcome;
 			typedef std::future<DeleteNodesOutcome> DeleteNodesOutcomeCallable;
 			typedef std::function<void(const EHPCClient*, const Model::DeleteNodesRequest&, const DeleteNodesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteNodesAsyncHandler;
+			typedef Outcome<Error, Model::StopVisualServiceResult> StopVisualServiceOutcome;
+			typedef std::future<StopVisualServiceOutcome> StopVisualServiceOutcomeCallable;
+			typedef std::function<void(const EHPCClient*, const Model::StopVisualServiceRequest&, const StopVisualServiceOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> StopVisualServiceAsyncHandler;
 			typedef Outcome<Error, Model::ListJobsResult> ListJobsOutcome;
 			typedef std::future<ListJobsOutcome> ListJobsOutcomeCallable;
 			typedef std::function<void(const EHPCClient*, const Model::ListJobsRequest&, const ListJobsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListJobsAsyncHandler;
 			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;
-			typedef Outcome<Error, Model::DescribeImageResult> DescribeImageOutcome;
-			typedef std::future<DescribeImageOutcome> DescribeImageOutcomeCallable;
-			typedef std::function<void(const EHPCClient*, const Model::DescribeImageRequest&, const DescribeImageOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeImageAsyncHandler;
 			typedef Outcome<Error, Model::ModifyUserPasswordsResult> ModifyUserPasswordsOutcome;
 			typedef std::future<ModifyUserPasswordsOutcome> ModifyUserPasswordsOutcomeCallable;
 			typedef std::function<void(const EHPCClient*, const Model::ModifyUserPasswordsRequest&, const ModifyUserPasswordsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ModifyUserPasswordsAsyncHandler;
+			typedef Outcome<Error, Model::DescribeImageResult> DescribeImageOutcome;
+			typedef std::future<DescribeImageOutcome> DescribeImageOutcomeCallable;
+			typedef std::function<void(const EHPCClient*, const Model::DescribeImageRequest&, const DescribeImageOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeImageAsyncHandler;
+			typedef Outcome<Error, Model::DeleteQueueResult> DeleteQueueOutcome;
+			typedef std::future<DeleteQueueOutcome> DeleteQueueOutcomeCallable;
+			typedef std::function<void(const EHPCClient*, const Model::DeleteQueueRequest&, const DeleteQueueOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteQueueAsyncHandler;
+			typedef Outcome<Error, Model::ListCpfsFileSystemsResult> ListCpfsFileSystemsOutcome;
+			typedef std::future<ListCpfsFileSystemsOutcome> ListCpfsFileSystemsOutcomeCallable;
+			typedef std::function<void(const EHPCClient*, const Model::ListCpfsFileSystemsRequest&, const ListCpfsFileSystemsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListCpfsFileSystemsAsyncHandler;
+			typedef Outcome<Error, Model::ListInstalledSoftwareResult> ListInstalledSoftwareOutcome;
+			typedef std::future<ListInstalledSoftwareOutcome> ListInstalledSoftwareOutcomeCallable;
+			typedef std::function<void(const EHPCClient*, const Model::ListInstalledSoftwareRequest&, const ListInstalledSoftwareOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListInstalledSoftwareAsyncHandler;
 			typedef Outcome<Error, Model::UpgradeClientResult> UpgradeClientOutcome;
 			typedef std::future<UpgradeClientOutcome> UpgradeClientOutcomeCallable;
 			typedef std::function<void(const EHPCClient*, const Model::UpgradeClientRequest&, const UpgradeClientOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> UpgradeClientAsyncHandler;
+			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::ListClustersMetaResult> ListClustersMetaOutcome;
+			typedef std::future<ListClustersMetaOutcome> ListClustersMetaOutcomeCallable;
+			typedef std::function<void(const EHPCClient*, const Model::ListClustersMetaRequest&, const ListClustersMetaOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListClustersMetaAsyncHandler;
 			typedef Outcome<Error, Model::DeleteClusterResult> DeleteClusterOutcome;
 			typedef std::future<DeleteClusterOutcome> DeleteClusterOutcomeCallable;
 			typedef std::function<void(const EHPCClient*, const Model::DeleteClusterRequest&, const DeleteClusterOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteClusterAsyncHandler;
@@ -328,9 +399,15 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::ListQueuesResult> ListQueuesOutcome;
 			typedef std::future<ListQueuesOutcome> ListQueuesOutcomeCallable;
 			typedef std::function<void(const EHPCClient*, const Model::ListQueuesRequest&, const ListQueuesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListQueuesAsyncHandler;
+			typedef Outcome<Error, Model::CreateJobFileResult> CreateJobFileOutcome;
+			typedef std::future<CreateJobFileOutcome> CreateJobFileOutcomeCallable;
+			typedef std::function<void(const EHPCClient*, const Model::CreateJobFileRequest&, const CreateJobFileOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateJobFileAsyncHandler;
 			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;
+			typedef Outcome<Error, Model::GetClusterVolumesResult> GetClusterVolumesOutcome;
+			typedef std::future<GetClusterVolumesOutcome> GetClusterVolumesOutcomeCallable;
+			typedef std::function<void(const EHPCClient*, const Model::GetClusterVolumesRequest&, const GetClusterVolumesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetClusterVolumesAsyncHandler;
 			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;
@@ -340,15 +417,24 @@ 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::GetAccountingReportResult> GetAccountingReportOutcome;
+			typedef std::future<GetAccountingReportOutcome> GetAccountingReportOutcomeCallable;
+			typedef std::function<void(const EHPCClient*, const Model::GetAccountingReportRequest&, const GetAccountingReportOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetAccountingReportAsyncHandler;
 			typedef Outcome<Error, Model::ListRegionsResult> ListRegionsOutcome;
 			typedef std::future<ListRegionsOutcome> ListRegionsOutcomeCallable;
 			typedef std::function<void(const EHPCClient*, const Model::ListRegionsRequest&, const ListRegionsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListRegionsAsyncHandler;
 			typedef Outcome<Error, Model::DescribeAutoScaleConfigResult> DescribeAutoScaleConfigOutcome;
 			typedef std::future<DescribeAutoScaleConfigOutcome> DescribeAutoScaleConfigOutcomeCallable;
 			typedef std::function<void(const EHPCClient*, const Model::DescribeAutoScaleConfigRequest&, const DescribeAutoScaleConfigOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeAutoScaleConfigAsyncHandler;
+			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;
 			typedef Outcome<Error, Model::RunCloudMetricProfilingResult> RunCloudMetricProfilingOutcome;
 			typedef std::future<RunCloudMetricProfilingOutcome> RunCloudMetricProfilingOutcomeCallable;
 			typedef std::function<void(const EHPCClient*, const Model::RunCloudMetricProfilingRequest&, const RunCloudMetricProfilingOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> RunCloudMetricProfilingAsyncHandler;
+			typedef Outcome<Error, Model::StartVisualServiceResult> StartVisualServiceOutcome;
+			typedef std::future<StartVisualServiceOutcome> StartVisualServiceOutcomeCallable;
+			typedef std::function<void(const EHPCClient*, const Model::StartVisualServiceRequest&, const StartVisualServiceOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> StartVisualServiceAsyncHandler;
 			typedef Outcome<Error, Model::DescribePriceResult> DescribePriceOutcome;
 			typedef std::future<DescribePriceOutcome> DescribePriceOutcomeCallable;
 			typedef std::function<void(const EHPCClient*, const Model::DescribePriceRequest&, const DescribePriceOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribePriceAsyncHandler;
@@ -361,12 +447,18 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::AddLocalNodesResult> AddLocalNodesOutcome;
 			typedef std::future<AddLocalNodesOutcome> AddLocalNodesOutcomeCallable;
 			typedef std::function<void(const EHPCClient*, const Model::AddLocalNodesRequest&, const AddLocalNodesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> AddLocalNodesAsyncHandler;
+			typedef Outcome<Error, Model::ModifyVisualServicePasswdResult> ModifyVisualServicePasswdOutcome;
+			typedef std::future<ModifyVisualServicePasswdOutcome> ModifyVisualServicePasswdOutcomeCallable;
+			typedef std::function<void(const EHPCClient*, const Model::ModifyVisualServicePasswdRequest&, const ModifyVisualServicePasswdOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ModifyVisualServicePasswdAsyncHandler;
 			typedef Outcome<Error, Model::ListPreferredEcsTypesResult> ListPreferredEcsTypesOutcome;
 			typedef std::future<ListPreferredEcsTypesOutcome> ListPreferredEcsTypesOutcomeCallable;
 			typedef std::function<void(const EHPCClient*, const Model::ListPreferredEcsTypesRequest&, const ListPreferredEcsTypesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListPreferredEcsTypesAsyncHandler;
 			typedef Outcome<Error, Model::AddContainerAppResult> AddContainerAppOutcome;
 			typedef std::future<AddContainerAppOutcome> AddContainerAppOutcomeCallable;
 			typedef std::function<void(const EHPCClient*, const Model::AddContainerAppRequest&, const AddContainerAppOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> AddContainerAppAsyncHandler;
+			typedef Outcome<Error, Model::InstallSoftwareResult> InstallSoftwareOutcome;
+			typedef std::future<InstallSoftwareOutcome> InstallSoftwareOutcomeCallable;
+			typedef std::function<void(const EHPCClient*, const Model::InstallSoftwareRequest&, const InstallSoftwareOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> InstallSoftwareAsyncHandler;
 			typedef Outcome<Error, Model::ListClusterLogsResult> ListClusterLogsOutcome;
 			typedef std::future<ListClusterLogsOutcome> ListClusterLogsOutcomeCallable;
 			typedef std::function<void(const EHPCClient*, const Model::ListClusterLogsRequest&, const ListClusterLogsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListClusterLogsAsyncHandler;
@@ -376,11 +468,17 @@ namespace AlibabaCloud
 			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::AddQueueResult> AddQueueOutcome;
+			typedef std::future<AddQueueOutcome> AddQueueOutcomeCallable;
+			typedef std::function<void(const EHPCClient*, const Model::AddQueueRequest&, const AddQueueOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> AddQueueAsyncHandler;
 
 			EHPCClient(const Credentials &credentials, const ClientConfiguration &configuration);
 			EHPCClient(const std::shared_ptr<CredentialsProvider> &credentialsProvider, const ClientConfiguration &configuration);
 			EHPCClient(const std::string &accessKeyId, const std::string &accessKeySecret, const ClientConfiguration &configuration);
 			~EHPCClient();
+			DescribeJobOutcome describeJob(const Model::DescribeJobRequest &request)const;
+			void describeJobAsync(const Model::DescribeJobRequest& request, const DescribeJobAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DescribeJobOutcomeCallable describeJobCallable(const Model::DescribeJobRequest& request) const;
 			DeleteImageOutcome deleteImage(const Model::DeleteImageRequest &request)const;
 			void deleteImageAsync(const Model::DeleteImageRequest& request, const DeleteImageAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			DeleteImageOutcomeCallable deleteImageCallable(const Model::DeleteImageRequest& request) const;
@@ -405,21 +503,27 @@ namespace AlibabaCloud
 			ListCurrentClientVersionOutcome listCurrentClientVersion(const Model::ListCurrentClientVersionRequest &request)const;
 			void listCurrentClientVersionAsync(const Model::ListCurrentClientVersionRequest& request, const ListCurrentClientVersionAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			ListCurrentClientVersionOutcomeCallable listCurrentClientVersionCallable(const Model::ListCurrentClientVersionRequest& request) const;
+			UpdateClusterVolumesOutcome updateClusterVolumes(const Model::UpdateClusterVolumesRequest &request)const;
+			void updateClusterVolumesAsync(const Model::UpdateClusterVolumesRequest& request, const UpdateClusterVolumesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			UpdateClusterVolumesOutcomeCallable updateClusterVolumesCallable(const Model::UpdateClusterVolumesRequest& request) const;
+			ListNodesByQueueOutcome listNodesByQueue(const Model::ListNodesByQueueRequest &request)const;
+			void listNodesByQueueAsync(const Model::ListNodesByQueueRequest& request, const ListNodesByQueueAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ListNodesByQueueOutcomeCallable listNodesByQueueCallable(const Model::ListNodesByQueueRequest& request) const;
 			ModifyContainerAppAttributesOutcome modifyContainerAppAttributes(const Model::ModifyContainerAppAttributesRequest &request)const;
 			void modifyContainerAppAttributesAsync(const Model::ModifyContainerAppAttributesRequest& request, const ModifyContainerAppAttributesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			ModifyContainerAppAttributesOutcomeCallable modifyContainerAppAttributesCallable(const Model::ModifyContainerAppAttributesRequest& request) const;
-			SetAutoScaleConfigOutcome setAutoScaleConfig(const Model::SetAutoScaleConfigRequest &request)const;
-			void setAutoScaleConfigAsync(const Model::SetAutoScaleConfigRequest& request, const SetAutoScaleConfigAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
-			SetAutoScaleConfigOutcomeCallable setAutoScaleConfigCallable(const Model::SetAutoScaleConfigRequest& request) const;
 			ListInvocationResultsOutcome listInvocationResults(const Model::ListInvocationResultsRequest &request)const;
 			void listInvocationResultsAsync(const Model::ListInvocationResultsRequest& request, const ListInvocationResultsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			ListInvocationResultsOutcomeCallable listInvocationResultsCallable(const Model::ListInvocationResultsRequest& request) const;
-			AddNodesOutcome addNodes(const Model::AddNodesRequest &request)const;
-			void addNodesAsync(const Model::AddNodesRequest& request, const AddNodesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
-			AddNodesOutcomeCallable addNodesCallable(const Model::AddNodesRequest& request) const;
+			SetAutoScaleConfigOutcome setAutoScaleConfig(const Model::SetAutoScaleConfigRequest &request)const;
+			void setAutoScaleConfigAsync(const Model::SetAutoScaleConfigRequest& request, const SetAutoScaleConfigAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			SetAutoScaleConfigOutcomeCallable setAutoScaleConfigCallable(const Model::SetAutoScaleConfigRequest& request) const;
 			ListSoftwaresOutcome listSoftwares(const Model::ListSoftwaresRequest &request)const;
 			void listSoftwaresAsync(const Model::ListSoftwaresRequest& request, const ListSoftwaresAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			ListSoftwaresOutcomeCallable listSoftwaresCallable(const Model::ListSoftwaresRequest& request) const;
+			AddNodesOutcome addNodes(const Model::AddNodesRequest &request)const;
+			void addNodesAsync(const Model::AddNodesRequest& request, const AddNodesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			AddNodesOutcomeCallable addNodesCallable(const Model::AddNodesRequest& request) const;
 			StopJobsOutcome stopJobs(const Model::StopJobsRequest &request)const;
 			void stopJobsAsync(const Model::StopJobsRequest& request, const StopJobsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			StopJobsOutcomeCallable stopJobsCallable(const Model::StopJobsRequest& request) const;
@@ -429,12 +533,12 @@ namespace AlibabaCloud
 			GetCloudMetricProfilingOutcome getCloudMetricProfiling(const Model::GetCloudMetricProfilingRequest &request)const;
 			void getCloudMetricProfilingAsync(const Model::GetCloudMetricProfilingRequest& request, const GetCloudMetricProfilingAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			GetCloudMetricProfilingOutcomeCallable getCloudMetricProfilingCallable(const Model::GetCloudMetricProfilingRequest& request) const;
-			DescribeImagePriceOutcome describeImagePrice(const Model::DescribeImagePriceRequest &request)const;
-			void describeImagePriceAsync(const Model::DescribeImagePriceRequest& request, const DescribeImagePriceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
-			DescribeImagePriceOutcomeCallable describeImagePriceCallable(const Model::DescribeImagePriceRequest& request) const;
 			GetAutoScaleConfigOutcome getAutoScaleConfig(const Model::GetAutoScaleConfigRequest &request)const;
 			void getAutoScaleConfigAsync(const Model::GetAutoScaleConfigRequest& request, const GetAutoScaleConfigAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			GetAutoScaleConfigOutcomeCallable getAutoScaleConfigCallable(const Model::GetAutoScaleConfigRequest& request) const;
+			DescribeImagePriceOutcome describeImagePrice(const Model::DescribeImagePriceRequest &request)const;
+			void describeImagePriceAsync(const Model::DescribeImagePriceRequest& request, const DescribeImagePriceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DescribeImagePriceOutcomeCallable describeImagePriceCallable(const Model::DescribeImagePriceRequest& request) const;
 			ListNodesOutcome listNodes(const Model::ListNodesRequest &request)const;
 			void listNodesAsync(const Model::ListNodesRequest& request, const ListNodesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			ListNodesOutcomeCallable listNodesCallable(const Model::ListNodesRequest& request) const;
@@ -444,6 +548,9 @@ namespace AlibabaCloud
 			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;
+			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;
 			ListCommandsOutcome listCommands(const Model::ListCommandsRequest &request)const;
 			void listCommandsAsync(const Model::ListCommandsRequest& request, const ListCommandsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			ListCommandsOutcomeCallable listCommandsCallable(const Model::ListCommandsRequest& request) const;
@@ -453,21 +560,21 @@ 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;
+			ListJobTemplatesOutcome listJobTemplates(const Model::ListJobTemplatesRequest &request)const;
+			void listJobTemplatesAsync(const Model::ListJobTemplatesRequest& request, const ListJobTemplatesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ListJobTemplatesOutcomeCallable listJobTemplatesCallable(const Model::ListJobTemplatesRequest& request) const;
 			ListFileSystemWithMountTargetsOutcome listFileSystemWithMountTargets(const Model::ListFileSystemWithMountTargetsRequest &request)const;
 			void listFileSystemWithMountTargetsAsync(const Model::ListFileSystemWithMountTargetsRequest& request, const ListFileSystemWithMountTargetsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			ListFileSystemWithMountTargetsOutcomeCallable listFileSystemWithMountTargetsCallable(const Model::ListFileSystemWithMountTargetsRequest& request) const;
 			AddUsersOutcome addUsers(const Model::AddUsersRequest &request)const;
 			void addUsersAsync(const Model::AddUsersRequest& request, const AddUsersAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			AddUsersOutcomeCallable addUsersCallable(const Model::AddUsersRequest& request) const;
-			ListJobTemplatesOutcome listJobTemplates(const Model::ListJobTemplatesRequest &request)const;
-			void listJobTemplatesAsync(const Model::ListJobTemplatesRequest& request, const ListJobTemplatesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
-			ListJobTemplatesOutcomeCallable listJobTemplatesCallable(const Model::ListJobTemplatesRequest& request) const;
-			ModifyClusterAttributesOutcome modifyClusterAttributes(const Model::ModifyClusterAttributesRequest &request)const;
-			void modifyClusterAttributesAsync(const Model::ModifyClusterAttributesRequest& request, const ModifyClusterAttributesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
-			ModifyClusterAttributesOutcomeCallable modifyClusterAttributesCallable(const Model::ModifyClusterAttributesRequest& request) const;
 			DescribeImageGatewayConfigOutcome describeImageGatewayConfig(const Model::DescribeImageGatewayConfigRequest &request)const;
 			void describeImageGatewayConfigAsync(const Model::DescribeImageGatewayConfigRequest& request, const DescribeImageGatewayConfigAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			DescribeImageGatewayConfigOutcomeCallable describeImageGatewayConfigCallable(const Model::DescribeImageGatewayConfigRequest& request) const;
+			ModifyClusterAttributesOutcome modifyClusterAttributes(const Model::ModifyClusterAttributesRequest &request)const;
+			void modifyClusterAttributesAsync(const Model::ModifyClusterAttributesRequest& request, const ModifyClusterAttributesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ModifyClusterAttributesOutcomeCallable modifyClusterAttributesCallable(const Model::ModifyClusterAttributesRequest& request) const;
 			DeleteJobTemplatesOutcome deleteJobTemplates(const Model::DeleteJobTemplatesRequest &request)const;
 			void deleteJobTemplatesAsync(const Model::DeleteJobTemplatesRequest& request, const DeleteJobTemplatesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			DeleteJobTemplatesOutcomeCallable deleteJobTemplatesCallable(const Model::DeleteJobTemplatesRequest& request) const;
@@ -480,15 +587,18 @@ namespace AlibabaCloud
 			GetCloudMetricLogsOutcome getCloudMetricLogs(const Model::GetCloudMetricLogsRequest &request)const;
 			void getCloudMetricLogsAsync(const Model::GetCloudMetricLogsRequest& request, const GetCloudMetricLogsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			GetCloudMetricLogsOutcomeCallable getCloudMetricLogsCallable(const Model::GetCloudMetricLogsRequest& request) const;
-			GetHybridClusterConfigOutcome getHybridClusterConfig(const Model::GetHybridClusterConfigRequest &request)const;
-			void getHybridClusterConfigAsync(const Model::GetHybridClusterConfigRequest& request, const GetHybridClusterConfigAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
-			GetHybridClusterConfigOutcomeCallable getHybridClusterConfigCallable(const Model::GetHybridClusterConfigRequest& request) const;
 			CreateJobTemplateOutcome createJobTemplate(const Model::CreateJobTemplateRequest &request)const;
 			void createJobTemplateAsync(const Model::CreateJobTemplateRequest& request, const CreateJobTemplateAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			CreateJobTemplateOutcomeCallable createJobTemplateCallable(const Model::CreateJobTemplateRequest& request) const;
+			GetHybridClusterConfigOutcome getHybridClusterConfig(const Model::GetHybridClusterConfigRequest &request)const;
+			void getHybridClusterConfigAsync(const Model::GetHybridClusterConfigRequest& request, const GetHybridClusterConfigAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			GetHybridClusterConfigOutcomeCallable getHybridClusterConfigCallable(const Model::GetHybridClusterConfigRequest& request) const;
 			ResetNodesOutcome resetNodes(const Model::ResetNodesRequest &request)const;
 			void resetNodesAsync(const Model::ResetNodesRequest& request, const ResetNodesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			ResetNodesOutcomeCallable resetNodesCallable(const Model::ResetNodesRequest& 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;
 			CreateHybridClusterOutcome createHybridCluster(const Model::CreateHybridClusterRequest &request)const;
 			void createHybridClusterAsync(const Model::CreateHybridClusterRequest& request, const CreateHybridClusterAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			CreateHybridClusterOutcomeCallable createHybridClusterCallable(const Model::CreateHybridClusterRequest& request) const;
@@ -501,21 +611,39 @@ namespace AlibabaCloud
 			DeleteNodesOutcome deleteNodes(const Model::DeleteNodesRequest &request)const;
 			void deleteNodesAsync(const Model::DeleteNodesRequest& request, const DeleteNodesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			DeleteNodesOutcomeCallable deleteNodesCallable(const Model::DeleteNodesRequest& request) const;
+			StopVisualServiceOutcome stopVisualService(const Model::StopVisualServiceRequest &request)const;
+			void stopVisualServiceAsync(const Model::StopVisualServiceRequest& request, const StopVisualServiceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			StopVisualServiceOutcomeCallable stopVisualServiceCallable(const Model::StopVisualServiceRequest& request) const;
 			ListJobsOutcome listJobs(const Model::ListJobsRequest &request)const;
 			void listJobsAsync(const Model::ListJobsRequest& request, const ListJobsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			ListJobsOutcomeCallable listJobsCallable(const Model::ListJobsRequest& 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;
-			DescribeImageOutcome describeImage(const Model::DescribeImageRequest &request)const;
-			void describeImageAsync(const Model::DescribeImageRequest& request, const DescribeImageAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
-			DescribeImageOutcomeCallable describeImageCallable(const Model::DescribeImageRequest& request) const;
 			ModifyUserPasswordsOutcome modifyUserPasswords(const Model::ModifyUserPasswordsRequest &request)const;
 			void modifyUserPasswordsAsync(const Model::ModifyUserPasswordsRequest& request, const ModifyUserPasswordsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			ModifyUserPasswordsOutcomeCallable modifyUserPasswordsCallable(const Model::ModifyUserPasswordsRequest& request) const;
+			DescribeImageOutcome describeImage(const Model::DescribeImageRequest &request)const;
+			void describeImageAsync(const Model::DescribeImageRequest& request, const DescribeImageAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DescribeImageOutcomeCallable describeImageCallable(const Model::DescribeImageRequest& request) const;
+			DeleteQueueOutcome deleteQueue(const Model::DeleteQueueRequest &request)const;
+			void deleteQueueAsync(const Model::DeleteQueueRequest& request, const DeleteQueueAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DeleteQueueOutcomeCallable deleteQueueCallable(const Model::DeleteQueueRequest& request) const;
+			ListCpfsFileSystemsOutcome listCpfsFileSystems(const Model::ListCpfsFileSystemsRequest &request)const;
+			void listCpfsFileSystemsAsync(const Model::ListCpfsFileSystemsRequest& request, const ListCpfsFileSystemsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ListCpfsFileSystemsOutcomeCallable listCpfsFileSystemsCallable(const Model::ListCpfsFileSystemsRequest& request) const;
+			ListInstalledSoftwareOutcome listInstalledSoftware(const Model::ListInstalledSoftwareRequest &request)const;
+			void listInstalledSoftwareAsync(const Model::ListInstalledSoftwareRequest& request, const ListInstalledSoftwareAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ListInstalledSoftwareOutcomeCallable listInstalledSoftwareCallable(const Model::ListInstalledSoftwareRequest& request) const;
 			UpgradeClientOutcome upgradeClient(const Model::UpgradeClientRequest &request)const;
 			void upgradeClientAsync(const Model::UpgradeClientRequest& request, const UpgradeClientAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			UpgradeClientOutcomeCallable upgradeClientCallable(const Model::UpgradeClientRequest& 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;
+			ListClustersMetaOutcome listClustersMeta(const Model::ListClustersMetaRequest &request)const;
+			void listClustersMetaAsync(const Model::ListClustersMetaRequest& request, const ListClustersMetaAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ListClustersMetaOutcomeCallable listClustersMetaCallable(const Model::ListClustersMetaRequest& request) const;
 			DeleteClusterOutcome deleteCluster(const Model::DeleteClusterRequest &request)const;
 			void deleteClusterAsync(const Model::DeleteClusterRequest& request, const DeleteClusterAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			DeleteClusterOutcomeCallable deleteClusterCallable(const Model::DeleteClusterRequest& request) const;
@@ -540,9 +668,15 @@ namespace AlibabaCloud
 			ListQueuesOutcome listQueues(const Model::ListQueuesRequest &request)const;
 			void listQueuesAsync(const Model::ListQueuesRequest& request, const ListQueuesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			ListQueuesOutcomeCallable listQueuesCallable(const Model::ListQueuesRequest& request) const;
+			CreateJobFileOutcome createJobFile(const Model::CreateJobFileRequest &request)const;
+			void createJobFileAsync(const Model::CreateJobFileRequest& request, const CreateJobFileAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			CreateJobFileOutcomeCallable createJobFileCallable(const Model::CreateJobFileRequest& 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;
+			GetClusterVolumesOutcome getClusterVolumes(const Model::GetClusterVolumesRequest &request)const;
+			void getClusterVolumesAsync(const Model::GetClusterVolumesRequest& request, const GetClusterVolumesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			GetClusterVolumesOutcomeCallable getClusterVolumesCallable(const Model::GetClusterVolumesRequest& 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;
@@ -552,15 +686,24 @@ 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;
+			GetAccountingReportOutcome getAccountingReport(const Model::GetAccountingReportRequest &request)const;
+			void getAccountingReportAsync(const Model::GetAccountingReportRequest& request, const GetAccountingReportAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			GetAccountingReportOutcomeCallable getAccountingReportCallable(const Model::GetAccountingReportRequest& request) const;
 			ListRegionsOutcome listRegions(const Model::ListRegionsRequest &request)const;
 			void listRegionsAsync(const Model::ListRegionsRequest& request, const ListRegionsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			ListRegionsOutcomeCallable listRegionsCallable(const Model::ListRegionsRequest& request) const;
 			DescribeAutoScaleConfigOutcome describeAutoScaleConfig(const Model::DescribeAutoScaleConfigRequest &request)const;
 			void describeAutoScaleConfigAsync(const Model::DescribeAutoScaleConfigRequest& request, const DescribeAutoScaleConfigAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			DescribeAutoScaleConfigOutcomeCallable describeAutoScaleConfigCallable(const Model::DescribeAutoScaleConfigRequest& 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;
 			RunCloudMetricProfilingOutcome runCloudMetricProfiling(const Model::RunCloudMetricProfilingRequest &request)const;
 			void runCloudMetricProfilingAsync(const Model::RunCloudMetricProfilingRequest& request, const RunCloudMetricProfilingAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			RunCloudMetricProfilingOutcomeCallable runCloudMetricProfilingCallable(const Model::RunCloudMetricProfilingRequest& request) const;
+			StartVisualServiceOutcome startVisualService(const Model::StartVisualServiceRequest &request)const;
+			void startVisualServiceAsync(const Model::StartVisualServiceRequest& request, const StartVisualServiceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			StartVisualServiceOutcomeCallable startVisualServiceCallable(const Model::StartVisualServiceRequest& request) const;
 			DescribePriceOutcome describePrice(const Model::DescribePriceRequest &request)const;
 			void describePriceAsync(const Model::DescribePriceRequest& request, const DescribePriceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			DescribePriceOutcomeCallable describePriceCallable(const Model::DescribePriceRequest& request) const;
@@ -573,12 +716,18 @@ namespace AlibabaCloud
 			AddLocalNodesOutcome addLocalNodes(const Model::AddLocalNodesRequest &request)const;
 			void addLocalNodesAsync(const Model::AddLocalNodesRequest& request, const AddLocalNodesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			AddLocalNodesOutcomeCallable addLocalNodesCallable(const Model::AddLocalNodesRequest& request) const;
+			ModifyVisualServicePasswdOutcome modifyVisualServicePasswd(const Model::ModifyVisualServicePasswdRequest &request)const;
+			void modifyVisualServicePasswdAsync(const Model::ModifyVisualServicePasswdRequest& request, const ModifyVisualServicePasswdAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ModifyVisualServicePasswdOutcomeCallable modifyVisualServicePasswdCallable(const Model::ModifyVisualServicePasswdRequest& request) const;
 			ListPreferredEcsTypesOutcome listPreferredEcsTypes(const Model::ListPreferredEcsTypesRequest &request)const;
 			void listPreferredEcsTypesAsync(const Model::ListPreferredEcsTypesRequest& request, const ListPreferredEcsTypesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			ListPreferredEcsTypesOutcomeCallable listPreferredEcsTypesCallable(const Model::ListPreferredEcsTypesRequest& request) const;
 			AddContainerAppOutcome addContainerApp(const Model::AddContainerAppRequest &request)const;
 			void addContainerAppAsync(const Model::AddContainerAppRequest& request, const AddContainerAppAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			AddContainerAppOutcomeCallable addContainerAppCallable(const Model::AddContainerAppRequest& request) const;
+			InstallSoftwareOutcome installSoftware(const Model::InstallSoftwareRequest &request)const;
+			void installSoftwareAsync(const Model::InstallSoftwareRequest& request, const InstallSoftwareAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			InstallSoftwareOutcomeCallable installSoftwareCallable(const Model::InstallSoftwareRequest& request) const;
 			ListClusterLogsOutcome listClusterLogs(const Model::ListClusterLogsRequest &request)const;
 			void listClusterLogsAsync(const Model::ListClusterLogsRequest& request, const ListClusterLogsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			ListClusterLogsOutcomeCallable listClusterLogsCallable(const Model::ListClusterLogsRequest& request) const;
@@ -588,6 +737,9 @@ namespace AlibabaCloud
 			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;
+			AddQueueOutcome addQueue(const Model::AddQueueRequest &request)const;
+			void addQueueAsync(const Model::AddQueueRequest& request, const AddQueueAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			AddQueueOutcomeCallable addQueueCallable(const Model::AddQueueRequest& request) const;
 	
 		private:
 			std::shared_ptr<EndpointProvider> endpointProvider_;

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

@@ -53,6 +53,8 @@ namespace AlibabaCloud
 				void setAccessKeyId(const std::string& accessKeyId);
 				std::string getImageOwnerAlias()const;
 				void setImageOwnerAlias(const std::string& imageOwnerAlias);
+				std::string getVSwitchId()const;
+				void setVSwitchId(const std::string& vSwitchId);
 				std::string getPeriodUnit()const;
 				void setPeriodUnit(const std::string& periodUnit);
 				std::string getAutoRenew()const;
@@ -61,8 +63,12 @@ namespace AlibabaCloud
 				void setEcsChargeType(const std::string& ecsChargeType);
 				std::string getCreateMode()const;
 				void setCreateMode(const std::string& createMode);
+				int getSystemDiskSize()const;
+				void setSystemDiskSize(int systemDiskSize);
 				std::string getInstanceType()const;
 				void setInstanceType(const std::string& instanceType);
+				std::string getZoneId()const;
+				void setZoneId(const std::string& zoneId);
 				std::string getComputeSpotPriceLimit()const;
 				void setComputeSpotPriceLimit(const std::string& computeSpotPriceLimit);
 
@@ -76,11 +82,14 @@ namespace AlibabaCloud
 				std::string jobQueue_;
 				std::string accessKeyId_;
 				std::string imageOwnerAlias_;
+				std::string vSwitchId_;
 				std::string periodUnit_;
 				std::string autoRenew_;
 				std::string ecsChargeType_;
 				std::string createMode_;
+				int systemDiskSize_;
 				std::string instanceType_;
+				std::string zoneId_;
 				std::string computeSpotPriceLimit_;
 
 			};

ehpc/include/alibabacloud/ehpc/model/AddQueueRequest.h

@@ -0,0 +1,54 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_EHPC_MODEL_ADDQUEUEREQUEST_H_
+#define ALIBABACLOUD_EHPC_MODEL_ADDQUEUEREQUEST_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 AddQueueRequest : public RpcServiceRequest
+			{
+
+			public:
+				AddQueueRequest();
+				~AddQueueRequest();
+
+				std::string getQueueName()const;
+				void setQueueName(const std::string& queueName);
+				std::string getClusterId()const;
+				void setClusterId(const std::string& clusterId);
+				std::string getAccessKeyId()const;
+				void setAccessKeyId(const std::string& accessKeyId);
+
+            private:
+				std::string queueName_;
+				std::string clusterId_;
+				std::string accessKeyId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_EHPC_MODEL_ADDQUEUEREQUEST_H_

ehpc/include/alibabacloud/ehpc/model/AddQueueResult.h

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

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

@@ -30,6 +30,18 @@ namespace AlibabaCloud
 		{
 			class ALIBABACLOUD_EHPC_EXPORT CreateClusterRequest : public RpcServiceRequest
 			{
+				struct AdditionalVolumes
+				{
+					std::string volumeType;
+					std::string volumeProtocol;
+					std::string localDirectory;
+					std::string remoteDirectory;
+					RepeatList roles;
+					std::string volumeId;
+					std::string volumeMountpoint;
+					std::string location;
+					std::string jobQueue;
+				};
 				struct PostInstallScript
 				{
 					std::string args;
@@ -48,6 +60,8 @@ namespace AlibabaCloud
 				void setSccClusterId(const std::string& sccClusterId);
 				std::string getImageId()const;
 				void setImageId(const std::string& imageId);
+				std::vector<AdditionalVolumes> getAdditionalVolumes()const;
+				void setAdditionalVolumes(const std::vector<AdditionalVolumes>& additionalVolumes);
 				std::string getEcsOrderManagerInstanceType()const;
 				void setEcsOrderManagerInstanceType(const std::string& ecsOrderManagerInstanceType);
 				std::string getEhpcVersion()const;
@@ -76,10 +90,16 @@ namespace AlibabaCloud
 				void setDeployMode(const std::string& deployMode);
 				int getEcsOrderManagerCount()const;
 				void setEcsOrderManagerCount(int ecsOrderManagerCount);
+				std::string getResourceGroupId()const;
+				void setResourceGroupId(const std::string& resourceGroupId);
 				std::string getPassword()const;
 				void setPassword(const std::string& password);
 				int getEcsOrderLoginCount()const;
 				void setEcsOrderLoginCount(int ecsOrderLoginCount);
+				std::string getRemoteVisEnable()const;
+				void setRemoteVisEnable(const std::string& remoteVisEnable);
+				int getSystemDiskSize()const;
+				void setSystemDiskSize(int systemDiskSize);
 				std::string getComputeSpotPriceLimit()const;
 				void setComputeSpotPriceLimit(const std::string& computeSpotPriceLimit);
 				int getAutoRenewPeriod()const;
@@ -132,6 +152,7 @@ namespace AlibabaCloud
             private:
 				std::string sccClusterId_;
 				std::string imageId_;
+				std::vector<AdditionalVolumes> additionalVolumes_;
 				std::string ecsOrderManagerInstanceType_;
 				std::string ehpcVersion_;
 				std::string accountType_;
@@ -146,8 +167,11 @@ namespace AlibabaCloud
 				std::string volumeType_;
 				std::string deployMode_;
 				int ecsOrderManagerCount_;
+				std::string resourceGroupId_;
 				std::string password_;
 				int ecsOrderLoginCount_;
+				std::string remoteVisEnable_;
+				int systemDiskSize_;
 				std::string computeSpotPriceLimit_;
 				int autoRenewPeriod_;
 				int period_;

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

@@ -64,6 +64,8 @@ namespace AlibabaCloud
 				void setAccessKeyId(const std::string& accessKeyId);
 				std::string getVolumeType()const;
 				void setVolumeType(const std::string& volumeType);
+				std::string getResourceGroupId()const;
+				void setResourceGroupId(const std::string& resourceGroupId);
 				std::string getPassword()const;
 				void setPassword(const std::string& password);
 				std::string getOnPremiseVolumeMountPoint()const;
@@ -114,6 +116,7 @@ namespace AlibabaCloud
 				std::string jobQueue_;
 				std::string accessKeyId_;
 				std::string volumeType_;
+				std::string resourceGroupId_;
 				std::string password_;
 				std::string onPremiseVolumeMountPoint_;
 				std::string onPremiseVolumeProtocol_;

ehpc/include/alibabacloud/ehpc/model/CreateJobFileRequest.h

@@ -0,0 +1,63 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_EHPC_MODEL_CREATEJOBFILEREQUEST_H_
+#define ALIBABACLOUD_EHPC_MODEL_CREATEJOBFILEREQUEST_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 CreateJobFileRequest : public RpcServiceRequest
+			{
+
+			public:
+				CreateJobFileRequest();
+				~CreateJobFileRequest();
+
+				std::string getTargetFile()const;
+				void setTargetFile(const std::string& targetFile);
+				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 getContent()const;
+				void setContent(const std::string& content);
+				std::string getAccessKeyId()const;
+				void setAccessKeyId(const std::string& accessKeyId);
+
+            private:
+				std::string targetFile_;
+				std::string runasUserPassword_;
+				std::string runasUser_;
+				std::string clusterId_;
+				std::string content_;
+				std::string accessKeyId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_EHPC_MODEL_CREATEJOBFILEREQUEST_H_

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

@@ -0,0 +1,51 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_EHPC_MODEL_CREATEJOBFILERESULT_H_
+#define ALIBABACLOUD_EHPC_MODEL_CREATEJOBFILERESULT_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 CreateJobFileResult : public ServiceResult
+			{
+			public:
+
+
+				CreateJobFileResult();
+				explicit CreateJobFileResult(const std::string &payload);
+				~CreateJobFileResult();
+				std::string getTemplateId()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string templateId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_EHPC_MODEL_CREATEJOBFILERESULT_H_

ehpc/include/alibabacloud/ehpc/model/DeleteQueueRequest.h

@@ -0,0 +1,54 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_EHPC_MODEL_DELETEQUEUEREQUEST_H_
+#define ALIBABACLOUD_EHPC_MODEL_DELETEQUEUEREQUEST_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 DeleteQueueRequest : public RpcServiceRequest
+			{
+
+			public:
+				DeleteQueueRequest();
+				~DeleteQueueRequest();
+
+				std::string getQueueName()const;
+				void setQueueName(const std::string& queueName);
+				std::string getClusterId()const;
+				void setClusterId(const std::string& clusterId);
+				std::string getAccessKeyId()const;
+				void setAccessKeyId(const std::string& accessKeyId);
+
+            private:
+				std::string queueName_;
+				std::string clusterId_;
+				std::string accessKeyId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_EHPC_MODEL_DELETEQUEUEREQUEST_H_

ehpc/include/alibabacloud/ehpc/model/DeleteQueueResult.h

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

ehpc/include/alibabacloud/ehpc/model/DescribeJobRequest.h

@@ -0,0 +1,54 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_EHPC_MODEL_DESCRIBEJOBREQUEST_H_
+#define ALIBABACLOUD_EHPC_MODEL_DESCRIBEJOBREQUEST_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 DescribeJobRequest : public RpcServiceRequest
+			{
+
+			public:
+				DescribeJobRequest();
+				~DescribeJobRequest();
+
+				std::string getJobId()const;
+				void setJobId(const std::string& jobId);
+				std::string getClusterId()const;
+				void setClusterId(const std::string& clusterId);
+				std::string getAccessKeyId()const;
+				void setAccessKeyId(const std::string& accessKeyId);
+
+            private:
+				std::string jobId_;
+				std::string clusterId_;
+				std::string accessKeyId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_EHPC_MODEL_DESCRIBEJOBREQUEST_H_

ehpc/include/alibabacloud/ehpc/model/DescribeJobResult.h

@@ -0,0 +1,55 @@
+/*
+ * 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_DESCRIBEJOBRESULT_H_
+#define ALIBABACLOUD_EHPC_MODEL_DESCRIBEJOBRESULT_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 DescribeJobResult : public ServiceResult
+			{
+			public:
+				struct Message
+				{
+					std::string jobInfo;
+				};
+
+
+				DescribeJobResult();
+				explicit DescribeJobResult(const std::string &payload);
+				~DescribeJobResult();
+				Message getMessage()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				Message message_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_EHPC_MODEL_DESCRIBEJOBRESULT_H_

ehpc/include/alibabacloud/ehpc/model/GetAccountingReportRequest.h

@@ -0,0 +1,60 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_EHPC_MODEL_GETACCOUNTINGREPORTREQUEST_H_
+#define ALIBABACLOUD_EHPC_MODEL_GETACCOUNTINGREPORTREQUEST_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 GetAccountingReportRequest : public RpcServiceRequest
+			{
+
+			public:
+				GetAccountingReportRequest();
+				~GetAccountingReportRequest();
+
+				std::string getReportType()const;
+				void setReportType(const std::string& reportType);
+				int getEndTime()const;
+				void setEndTime(int endTime);
+				std::string getClusterId()const;
+				void setClusterId(const std::string& clusterId);
+				int getStartTime()const;
+				void setStartTime(int startTime);
+				std::string getAccessKeyId()const;
+				void setAccessKeyId(const std::string& accessKeyId);
+
+            private:
+				std::string reportType_;
+				int endTime_;
+				std::string clusterId_;
+				int startTime_;
+				std::string accessKeyId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_EHPC_MODEL_GETACCOUNTINGREPORTREQUEST_H_

ehpc/include/alibabacloud/ehpc/model/GetAccountingReportResult.h

@@ -0,0 +1,53 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_EHPC_MODEL_GETACCOUNTINGREPORTRESULT_H_
+#define ALIBABACLOUD_EHPC_MODEL_GETACCOUNTINGREPORTRESULT_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 GetAccountingReportResult : public ServiceResult
+			{
+			public:
+
+
+				GetAccountingReportResult();
+				explicit GetAccountingReportResult(const std::string &payload);
+				~GetAccountingReportResult();
+				std::string getMetrics()const;
+				std::string getData()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string metrics_;
+				std::string data_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_EHPC_MODEL_GETACCOUNTINGREPORTRESULT_H_

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

@@ -34,8 +34,15 @@ namespace AlibabaCloud
 			public:
 				struct QueueInfo
 				{
+					struct InstanceTypeInfo
+					{
+						float spotPriceLimit;
+						std::string instanceType;
+						std::string spotStrategy;
+					};
 					bool enableAutoGrow;
 					float spotPriceLimit;
+					std::vector<QueueInfo::InstanceTypeInfo> instanceTypes;
 					bool enableAutoShrink;
 					std::string instanceType;
 					std::string queueName;

ehpc/include/alibabacloud/ehpc/model/GetClusterVolumesRequest.h

@@ -0,0 +1,51 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_EHPC_MODEL_GETCLUSTERVOLUMESREQUEST_H_
+#define ALIBABACLOUD_EHPC_MODEL_GETCLUSTERVOLUMESREQUEST_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 GetClusterVolumesRequest : public RpcServiceRequest
+			{
+
+			public:
+				GetClusterVolumesRequest();
+				~GetClusterVolumesRequest();
+
+				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_GETCLUSTERVOLUMESREQUEST_H_

ehpc/include/alibabacloud/ehpc/model/GetClusterVolumesResult.h

@@ -0,0 +1,70 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_EHPC_MODEL_GETCLUSTERVOLUMESRESULT_H_
+#define ALIBABACLOUD_EHPC_MODEL_GETCLUSTERVOLUMESRESULT_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 GetClusterVolumesResult : public ServiceResult
+			{
+			public:
+				struct VolumeInfo
+				{
+					struct RoleInfo
+					{
+						std::string name;
+					};
+					std::string volumeProtocol;
+					std::string volumeId;
+					std::string remoteDirectory;
+					std::string localDirectory;
+					std::string volumeType;
+					std::string jobQueue;
+					bool mustKeep;
+					std::vector<VolumeInfo::RoleInfo> roles;
+					std::string volumeMountpoint;
+					std::string location;
+				};
+
+
+				GetClusterVolumesResult();
+				explicit GetClusterVolumesResult(const std::string &payload);
+				~GetClusterVolumesResult();
+				std::vector<VolumeInfo> getVolumes()const;
+				std::string getRegionId()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::vector<VolumeInfo> volumes_;
+				std::string regionId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_EHPC_MODEL_GETCLUSTERVOLUMESRESULT_H_

ehpc/include/alibabacloud/ehpc/model/GetVisualServiceStatusRequest.h

@@ -0,0 +1,51 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_EHPC_MODEL_GETVISUALSERVICESTATUSREQUEST_H_
+#define ALIBABACLOUD_EHPC_MODEL_GETVISUALSERVICESTATUSREQUEST_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 GetVisualServiceStatusRequest : public RpcServiceRequest
+			{
+
+			public:
+				GetVisualServiceStatusRequest();
+				~GetVisualServiceStatusRequest();
+
+				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_GETVISUALSERVICESTATUSREQUEST_H_

ehpc/include/alibabacloud/ehpc/model/GetVisualServiceStatusResult.h

@@ -0,0 +1,51 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_EHPC_MODEL_GETVISUALSERVICESTATUSRESULT_H_
+#define ALIBABACLOUD_EHPC_MODEL_GETVISUALSERVICESTATUSRESULT_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 GetVisualServiceStatusResult : public ServiceResult
+			{
+			public:
+
+
+				GetVisualServiceStatusResult();
+				explicit GetVisualServiceStatusResult(const std::string &payload);
+				~GetVisualServiceStatusResult();
+				std::string getMessage()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string message_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_EHPC_MODEL_GETVISUALSERVICESTATUSRESULT_H_

ehpc/include/alibabacloud/ehpc/model/InstallSoftwareRequest.h

@@ -0,0 +1,54 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_EHPC_MODEL_INSTALLSOFTWAREREQUEST_H_
+#define ALIBABACLOUD_EHPC_MODEL_INSTALLSOFTWAREREQUEST_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 InstallSoftwareRequest : public RpcServiceRequest
+			{
+
+			public:
+				InstallSoftwareRequest();
+				~InstallSoftwareRequest();
+
+				std::string getApplication()const;
+				void setApplication(const std::string& application);
+				std::string getClusterId()const;
+				void setClusterId(const std::string& clusterId);
+				std::string getAccessKeyId()const;
+				void setAccessKeyId(const std::string& accessKeyId);
+
+            private:
+				std::string application_;
+				std::string clusterId_;
+				std::string accessKeyId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_EHPC_MODEL_INSTALLSOFTWAREREQUEST_H_

ehpc/include/alibabacloud/ehpc/model/InstallSoftwareResult.h

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

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

@@ -0,0 +1,48 @@
+/*
+ * 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

@@ -0,0 +1,58 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#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/ListClustersMetaRequest.h

@@ -0,0 +1,54 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_EHPC_MODEL_LISTCLUSTERSMETAREQUEST_H_
+#define ALIBABACLOUD_EHPC_MODEL_LISTCLUSTERSMETAREQUEST_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 ListClustersMetaRequest : public RpcServiceRequest
+			{
+
+			public:
+				ListClustersMetaRequest();
+				~ListClustersMetaRequest();
+
+				int getPageSize()const;
+				void setPageSize(int pageSize);
+				int getPageNumber()const;
+				void setPageNumber(int pageNumber);
+				std::string getAccessKeyId()const;
+				void setAccessKeyId(const std::string& accessKeyId);
+
+            private:
+				int pageSize_;
+				int pageNumber_;
+				std::string accessKeyId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_EHPC_MODEL_LISTCLUSTERSMETAREQUEST_H_

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

@@ -0,0 +1,64 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_EHPC_MODEL_LISTCLUSTERSMETARESULT_H_
+#define ALIBABACLOUD_EHPC_MODEL_LISTCLUSTERSMETARESULT_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 ListClustersMetaResult : public ServiceResult
+			{
+			public:
+				struct ClusterInfoSimple
+				{
+					std::string status;
+					std::string description;
+					std::string id;
+					std::string name;
+				};
+
+
+				ListClustersMetaResult();
+				explicit ListClustersMetaResult(const std::string &payload);
+				~ListClustersMetaResult();
+				int getTotalCount()const;
+				int getPageSize()const;
+				int getPageNumber()const;
+				std::vector<ClusterInfoSimple> getClusters()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				int totalCount_;
+				int pageSize_;
+				int pageNumber_;
+				std::vector<ClusterInfoSimple> clusters_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_EHPC_MODEL_LISTCLUSTERSMETARESULT_H_

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

@@ -66,12 +66,15 @@ namespace AlibabaCloud
 					std::string imageOwnerAlias;
 					std::string description;
 					std::string zoneId;
+					std::string vSwitchId;
 					std::string createTime;
 					std::string schedulerType;
 					int count;
 					std::string accountType;
+					std::string ehpcVersion;
 					std::string name;
 					UsedResources usedResources;
+					std::string vpcId;
 					std::string deployMode;
 					Managers managers;
 					TotalResources totalResources;

ehpc/include/alibabacloud/ehpc/model/ListCpfsFileSystemsRequest.h

@@ -0,0 +1,57 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_EHPC_MODEL_LISTCPFSFILESYSTEMSREQUEST_H_
+#define ALIBABACLOUD_EHPC_MODEL_LISTCPFSFILESYSTEMSREQUEST_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 ListCpfsFileSystemsRequest : public RpcServiceRequest
+			{
+
+			public:
+				ListCpfsFileSystemsRequest();
+				~ListCpfsFileSystemsRequest();
+
+				int getPageSize()const;
+				void setPageSize(int pageSize);
+				int getPageNumber()const;
+				void setPageNumber(int pageNumber);
+				std::string getAccessKeyId()const;
+				void setAccessKeyId(const std::string& accessKeyId);
+				std::string getFileSystemId()const;
+				void setFileSystemId(const std::string& fileSystemId);
+
+            private:
+				int pageSize_;
+				int pageNumber_;
+				std::string accessKeyId_;
+				std::string fileSystemId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_EHPC_MODEL_LISTCPFSFILESYSTEMSREQUEST_H_

ehpc/include/alibabacloud/ehpc/model/ListCpfsFileSystemsResult.h

@@ -0,0 +1,76 @@
+/*
+ * 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_LISTCPFSFILESYSTEMSRESULT_H_
+#define ALIBABACLOUD_EHPC_MODEL_LISTCPFSFILESYSTEMSRESULT_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 ListCpfsFileSystemsResult : public ServiceResult
+			{
+			public:
+				struct FileSystems
+				{
+					struct MountTargets
+					{
+						std::string status;
+						std::string vswId;
+						std::string vpcId;
+						std::string mountTargetDomain;
+						std::string networkType;
+					};
+					std::string zoneId;
+					std::string capacity;
+					std::string protocolType;
+					std::string createTime;
+					std::vector<FileSystems::MountTargets> mountTargetList;
+					std::string destription;
+					std::string fileSystemId;
+					std::string regionId;
+				};
+
+
+				ListCpfsFileSystemsResult();
+				explicit ListCpfsFileSystemsResult(const std::string &payload);
+				~ListCpfsFileSystemsResult();
+				int getTotalCount()const;
+				int getPageSize()const;
+				int getPageNumber()const;
+				std::vector<FileSystems> getFileSystemList()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				int totalCount_;
+				int pageSize_;
+				int pageNumber_;
+				std::vector<FileSystems> fileSystemList_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_EHPC_MODEL_LISTCPFSFILESYSTEMSRESULT_H_

ehpc/include/alibabacloud/ehpc/model/ListCustomImagesResult.h

@@ -50,6 +50,7 @@ namespace AlibabaCloud
 					std::string productCode;
 					std::string skuCode;
 					std::string pricingCycle;
+					int size;
 					std::string imageId;
 					BaseOsTag baseOsTag;
 				};

ehpc/include/alibabacloud/ehpc/model/ListInstalledSoftwareRequest.h

@@ -0,0 +1,51 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_EHPC_MODEL_LISTINSTALLEDSOFTWAREREQUEST_H_
+#define ALIBABACLOUD_EHPC_MODEL_LISTINSTALLEDSOFTWAREREQUEST_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 ListInstalledSoftwareRequest : public RpcServiceRequest
+			{
+
+			public:
+				ListInstalledSoftwareRequest();
+				~ListInstalledSoftwareRequest();
+
+				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_LISTINSTALLEDSOFTWAREREQUEST_H_

ehpc/include/alibabacloud/ehpc/model/ListInstalledSoftwareResult.h

@@ -0,0 +1,58 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_EHPC_MODEL_LISTINSTALLEDSOFTWARERESULT_H_
+#define ALIBABACLOUD_EHPC_MODEL_LISTINSTALLEDSOFTWARERESULT_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 ListInstalledSoftwareResult : public ServiceResult
+			{
+			public:
+				struct SoftwareListItem
+				{
+					std::string softwareId;
+					std::string softwareVersion;
+					std::string softwareStatus;
+					std::string softwareName;
+				};
+
+
+				ListInstalledSoftwareResult();
+				explicit ListInstalledSoftwareResult(const std::string &payload);
+				~ListInstalledSoftwareResult();
+				std::vector<SoftwareListItem> getSoftwareList()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::vector<SoftwareListItem> softwareList_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_EHPC_MODEL_LISTINSTALLEDSOFTWARERESULT_H_

ehpc/include/alibabacloud/ehpc/model/ListNodesByQueueRequest.h

@@ -0,0 +1,60 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_EHPC_MODEL_LISTNODESBYQUEUEREQUEST_H_
+#define ALIBABACLOUD_EHPC_MODEL_LISTNODESBYQUEUEREQUEST_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 ListNodesByQueueRequest : public RpcServiceRequest
+			{
+
+			public:
+				ListNodesByQueueRequest();
+				~ListNodesByQueueRequest();
+
+				std::string getQueueName()const;
+				void setQueueName(const std::string& queueName);
+				int getPageSize()const;
+				void setPageSize(int pageSize);
+				std::string getClusterId()const;
+				void setClusterId(const std::string& clusterId);
+				int getPageNumber()const;
+				void setPageNumber(int pageNumber);
+				std::string getAccessKeyId()const;
+				void setAccessKeyId(const std::string& accessKeyId);
+
+            private:
+				std::string queueName_;
+				int pageSize_;
+				std::string clusterId_;
+				int pageNumber_;
+				std::string accessKeyId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_EHPC_MODEL_LISTNODESBYQUEUEREQUEST_H_

ehpc/include/alibabacloud/ehpc/model/ListNodesByQueueResult.h

@@ -0,0 +1,89 @@
+/*
+ * 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_LISTNODESBYQUEUERESULT_H_
+#define ALIBABACLOUD_EHPC_MODEL_LISTNODESBYQUEUERESULT_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 ListNodesByQueueResult : public ServiceResult
+			{
+			public:
+				struct NodeInfo
+				{
+					struct TotalResources
+					{
+						int memory;
+						int cpu;
+						int gpu;
+					};
+					struct UsedResources
+					{
+						int memory;
+						int cpu;
+						int gpu;
+					};
+					std::string status;
+					std::string imageOwnerAlias;
+					bool expired;
+					std::string addTime;
+					UsedResources usedResources;
+					bool createdByEhpc;
+					std::string createMode;
+					std::string version;
+					TotalResources totalResources;
+					std::string expiredTime;
+					std::string imageId;
+					std::string id;
+					std::string regionId;
+					std::string lockReason;
+					std::string hostName;
+					std::string spotStrategy;
+					std::string location;
+				};
+
+
+				ListNodesByQueueResult();
+				explicit ListNodesByQueueResult(const std::string &payload);
+				~ListNodesByQueueResult();
+				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_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_EHPC_MODEL_LISTNODESBYQUEUERESULT_H_

ehpc/include/alibabacloud/ehpc/model/ListVolumesResult.h

@@ -34,11 +34,24 @@ namespace AlibabaCloud
 			public:
 				struct VolumeInfo
 				{
+					struct VolumeInfo1
+					{
+						std::string volumeProtocol;
+						std::string role;
+						std::string volumeId;
+						std::string remoteDirectory;
+						std::string localDirectory;
+						std::string volumeType;
+						std::string jobQueue;
+						std::string volumeMountpoint;
+						std::string location;
+					};
 					std::string volumeProtocol;
 					std::string volumeId;
 					std::string remoteDirectory;
 					std::string volumeType;
 					std::string clusterId;
+					std::vector<VolumeInfo::VolumeInfo1> additionalVolumes;
 					std::string clusterName;
 					std::string regionId;
 					std::string volumeMountpoint;

ehpc/include/alibabacloud/ehpc/model/ModifyVisualServicePasswdRequest.h

@@ -0,0 +1,60 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_EHPC_MODEL_MODIFYVISUALSERVICEPASSWDREQUEST_H_
+#define ALIBABACLOUD_EHPC_MODEL_MODIFYVISUALSERVICEPASSWDREQUEST_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 ModifyVisualServicePasswdRequest : public RpcServiceRequest
+			{
+
+			public:
+				ModifyVisualServicePasswdRequest();
+				~ModifyVisualServicePasswdRequest();
+
+				std::string getPasswd()const;
+				void setPasswd(const std::string& passwd);
+				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 passwd_;
+				std::string runasUserPassword_;
+				std::string runasUser_;
+				std::string clusterId_;
+				std::string accessKeyId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_EHPC_MODEL_MODIFYVISUALSERVICEPASSWDREQUEST_H_

ehpc/include/alibabacloud/ehpc/model/ModifyVisualServicePasswdResult.h

@@ -0,0 +1,51 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_EHPC_MODEL_MODIFYVISUALSERVICEPASSWDRESULT_H_
+#define ALIBABACLOUD_EHPC_MODEL_MODIFYVISUALSERVICEPASSWDRESULT_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 ModifyVisualServicePasswdResult : public ServiceResult
+			{
+			public:
+
+
+				ModifyVisualServicePasswdResult();
+				explicit ModifyVisualServicePasswdResult(const std::string &payload);
+				~ModifyVisualServicePasswdResult();
+				std::string getMessage()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string message_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_EHPC_MODEL_MODIFYVISUALSERVICEPASSWDRESULT_H_

ehpc/include/alibabacloud/ehpc/model/RecoverClusterRequest.h

@@ -35,14 +35,32 @@ namespace AlibabaCloud
 				RecoverClusterRequest();
 				~RecoverClusterRequest();
 
+				std::string getImageId()const;
+				void setImageId(const std::string& imageId);
+				std::string getOsTag()const;
+				void setOsTag(const std::string& osTag);
+				std::string getClientVersion()const;
+				void setClientVersion(const std::string& clientVersion);
+				std::string getAccountType()const;
+				void setAccountType(const std::string& accountType);
+				std::string getSchedulerType()const;
+				void setSchedulerType(const std::string& schedulerType);
 				std::string getClusterId()const;
 				void setClusterId(const std::string& clusterId);
 				std::string getAccessKeyId()const;
 				void setAccessKeyId(const std::string& accessKeyId);
+				std::string getImageOwnerAlias()const;
+				void setImageOwnerAlias(const std::string& imageOwnerAlias);
 
             private:
+				std::string imageId_;
+				std::string osTag_;
+				std::string clientVersion_;
+				std::string accountType_;
+				std::string schedulerType_;
 				std::string clusterId_;
 				std::string accessKeyId_;
+				std::string imageOwnerAlias_;
 
 			};
 		}

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

@@ -34,6 +34,7 @@ namespace AlibabaCloud
 				{
 					std::string spotStrategy;
 					std::string queueName;
+					RepeatList instanceTypes;
 					std::string instanceType;
 					bool enableAutoGrow;
 					float spotPriceLimit;

ehpc/include/alibabacloud/ehpc/model/SetQueueRequest.h

@@ -0,0 +1,61 @@
+/*
+ * 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_SETQUEUEREQUEST_H_
+#define ALIBABACLOUD_EHPC_MODEL_SETQUEUEREQUEST_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 SetQueueRequest : public RpcServiceRequest
+			{
+				struct Node
+				{
+					std::string name;
+				};
+
+			public:
+				SetQueueRequest();
+				~SetQueueRequest();
+
+				std::string getQueueName()const;
+				void setQueueName(const std::string& queueName);
+				std::vector<Node> getNode()const;
+				void setNode(const std::vector<Node>& node);
+				std::string getClusterId()const;
+				void setClusterId(const std::string& clusterId);
+				std::string getAccessKeyId()const;
+				void setAccessKeyId(const std::string& accessKeyId);
+
+            private:
+				std::string queueName_;
+				std::vector<Node> node_;
+				std::string clusterId_;
+				std::string accessKeyId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_EHPC_MODEL_SETQUEUEREQUEST_H_

ehpc/include/alibabacloud/ehpc/model/SetQueueResult.h

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

ehpc/include/alibabacloud/ehpc/model/StartVisualServiceRequest.h

@@ -0,0 +1,57 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_EHPC_MODEL_STARTVISUALSERVICEREQUEST_H_
+#define ALIBABACLOUD_EHPC_MODEL_STARTVISUALSERVICEREQUEST_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 StartVisualServiceRequest : public RpcServiceRequest
+			{
+
+			public:
+				StartVisualServiceRequest();
+				~StartVisualServiceRequest();
+
+				int getPort()const;
+				void setPort(int port);
+				std::string getClusterId()const;
+				void setClusterId(const std::string& clusterId);
+				std::string getCidrIp()const;
+				void setCidrIp(const std::string& cidrIp);
+				std::string getAccessKeyId()const;
+				void setAccessKeyId(const std::string& accessKeyId);
+
+            private:
+				int port_;
+				std::string clusterId_;
+				std::string cidrIp_;
+				std::string accessKeyId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_EHPC_MODEL_STARTVISUALSERVICEREQUEST_H_

ehpc/include/alibabacloud/ehpc/model/StartVisualServiceResult.h

@@ -0,0 +1,51 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_EHPC_MODEL_STARTVISUALSERVICERESULT_H_
+#define ALIBABACLOUD_EHPC_MODEL_STARTVISUALSERVICERESULT_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 StartVisualServiceResult : public ServiceResult
+			{
+			public:
+
+
+				StartVisualServiceResult();
+				explicit StartVisualServiceResult(const std::string &payload);
+				~StartVisualServiceResult();
+				std::string getMessage()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string message_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_EHPC_MODEL_STARTVISUALSERVICERESULT_H_

ehpc/include/alibabacloud/ehpc/model/StopVisualServiceRequest.h

@@ -0,0 +1,57 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_EHPC_MODEL_STOPVISUALSERVICEREQUEST_H_
+#define ALIBABACLOUD_EHPC_MODEL_STOPVISUALSERVICEREQUEST_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 StopVisualServiceRequest : public RpcServiceRequest
+			{
+
+			public:
+				StopVisualServiceRequest();
+				~StopVisualServiceRequest();
+
+				int getPort()const;
+				void setPort(int port);
+				std::string getClusterId()const;
+				void setClusterId(const std::string& clusterId);
+				std::string getCidrIp()const;
+				void setCidrIp(const std::string& cidrIp);
+				std::string getAccessKeyId()const;
+				void setAccessKeyId(const std::string& accessKeyId);
+
+            private:
+				int port_;
+				std::string clusterId_;
+				std::string cidrIp_;
+				std::string accessKeyId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_EHPC_MODEL_STOPVISUALSERVICEREQUEST_H_

ehpc/include/alibabacloud/ehpc/model/StopVisualServiceResult.h

@@ -0,0 +1,51 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_EHPC_MODEL_STOPVISUALSERVICERESULT_H_
+#define ALIBABACLOUD_EHPC_MODEL_STOPVISUALSERVICERESULT_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 StopVisualServiceResult : public ServiceResult
+			{
+			public:
+
+
+				StopVisualServiceResult();
+				explicit StopVisualServiceResult(const std::string &payload);
+				~StopVisualServiceResult();
+				std::string getMessage()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string message_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_EHPC_MODEL_STOPVISUALSERVICERESULT_H_

ehpc/include/alibabacloud/ehpc/model/UninstallSoftwareRequest.h

@@ -0,0 +1,54 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_EHPC_MODEL_UNINSTALLSOFTWAREREQUEST_H_
+#define ALIBABACLOUD_EHPC_MODEL_UNINSTALLSOFTWAREREQUEST_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 UninstallSoftwareRequest : public RpcServiceRequest
+			{
+
+			public:
+				UninstallSoftwareRequest();
+				~UninstallSoftwareRequest();
+
+				std::string getApplication()const;
+				void setApplication(const std::string& application);
+				std::string getClusterId()const;
+				void setClusterId(const std::string& clusterId);
+				std::string getAccessKeyId()const;
+				void setAccessKeyId(const std::string& accessKeyId);
+
+            private:
+				std::string application_;
+				std::string clusterId_;
+				std::string accessKeyId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_EHPC_MODEL_UNINSTALLSOFTWAREREQUEST_H_

ehpc/include/alibabacloud/ehpc/model/UninstallSoftwareResult.h

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

ehpc/include/alibabacloud/ehpc/model/UpdateClusterVolumesRequest.h

@@ -0,0 +1,66 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_EHPC_MODEL_UPDATECLUSTERVOLUMESREQUEST_H_
+#define ALIBABACLOUD_EHPC_MODEL_UPDATECLUSTERVOLUMESREQUEST_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 UpdateClusterVolumesRequest : public RpcServiceRequest
+			{
+				struct AdditionalVolumes
+				{
+					std::string volumeType;
+					std::string volumeProtocol;
+					std::string localDirectory;
+					std::string remoteDirectory;
+					RepeatList roles;
+					std::string volumeId;
+					std::string volumeMountpoint;
+					std::string location;
+					std::string jobQueue;
+				};
+
+			public:
+				UpdateClusterVolumesRequest();
+				~UpdateClusterVolumesRequest();
+
+				std::vector<AdditionalVolumes> getAdditionalVolumes()const;
+				void setAdditionalVolumes(const std::vector<AdditionalVolumes>& additionalVolumes);
+				std::string getClusterId()const;
+				void setClusterId(const std::string& clusterId);
+				std::string getAccessKeyId()const;
+				void setAccessKeyId(const std::string& accessKeyId);
+
+            private:
+				std::vector<AdditionalVolumes> additionalVolumes_;
+				std::string clusterId_;
+				std::string accessKeyId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_EHPC_MODEL_UPDATECLUSTERVOLUMESREQUEST_H_

ehpc/include/alibabacloud/ehpc/model/UpdateClusterVolumesResult.h

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

ehpc/src/model/AddContainerAppRequest.cc

@@ -33,7 +33,7 @@ std::string AddContainerAppRequest::getContainerType()const
 void AddContainerAppRequest::setContainerType(const std::string& containerType)
 {
 	containerType_ = containerType;
-	setParameter("ContainerType", containerType);
+	setCoreParameter("ContainerType", containerType);
 }
 
 std::string AddContainerAppRequest::getName()const
@@ -44,7 +44,7 @@ std::string AddContainerAppRequest::getName()const
 void AddContainerAppRequest::setName(const std::string& name)
 {
 	name_ = name;
-	setParameter("Name", name);
+	setCoreParameter("Name", name);
 }
 
 std::string AddContainerAppRequest::getDescription()const
@@ -55,7 +55,7 @@ std::string AddContainerAppRequest::getDescription()const
 void AddContainerAppRequest::setDescription(const std::string& description)
 {
 	description_ = description;
-	setParameter("Description", description);
+	setCoreParameter("Description", description);
 }
 
 std::string AddContainerAppRequest::getRepository()const
@@ -66,7 +66,7 @@ std::string AddContainerAppRequest::getRepository()const
 void AddContainerAppRequest::setRepository(const std::string& repository)
 {
 	repository_ = repository;
-	setParameter("Repository", repository);
+	setCoreParameter("Repository", repository);
 }
 
 std::string AddContainerAppRequest::getImageTag()const
@@ -77,7 +77,7 @@ std::string AddContainerAppRequest::getImageTag()const
 void AddContainerAppRequest::setImageTag(const std::string& imageTag)
 {
 	imageTag_ = imageTag;
-	setParameter("ImageTag", imageTag);
+	setCoreParameter("ImageTag", imageTag);
 }
 
 std::string AddContainerAppRequest::getAccessKeyId()const
@@ -88,6 +88,6 @@ std::string AddContainerAppRequest::getAccessKeyId()const
 void AddContainerAppRequest::setAccessKeyId(const std::string& accessKeyId)
 {
 	accessKeyId_ = accessKeyId;
-	setParameter("AccessKeyId", accessKeyId);
+	setCoreParameter("AccessKeyId", accessKeyId);
 }
 

ehpc/src/model/AddLocalNodesRequest.cc

@@ -33,7 +33,7 @@ std::string AddLocalNodesRequest::getNodes()const
 void AddLocalNodesRequest::setNodes(const std::string& nodes)
 {
 	nodes_ = nodes;
-	setParameter("Nodes", nodes);
+	setCoreParameter("Nodes", nodes);
 }
 
 std::string AddLocalNodesRequest::getClusterId()const
@@ -44,7 +44,7 @@ std::string AddLocalNodesRequest::getClusterId()const
 void AddLocalNodesRequest::setClusterId(const std::string& clusterId)
 {
 	clusterId_ = clusterId;
-	setParameter("ClusterId", clusterId);
+	setCoreParameter("ClusterId", clusterId);
 }
 
 std::string AddLocalNodesRequest::getAccessKeyId()const
@@ -55,6 +55,6 @@ std::string AddLocalNodesRequest::getAccessKeyId()const
 void AddLocalNodesRequest::setAccessKeyId(const std::string& accessKeyId)
 {
 	accessKeyId_ = accessKeyId;
-	setParameter("AccessKeyId", accessKeyId);
+	setCoreParameter("AccessKeyId", accessKeyId);
 }
 

ehpc/src/model/AddNodesRequest.cc

@@ -33,7 +33,7 @@ int AddNodesRequest::getAutoRenewPeriod()const
 void AddNodesRequest::setAutoRenewPeriod(int autoRenewPeriod)
 {
 	autoRenewPeriod_ = autoRenewPeriod;
-	setParameter("AutoRenewPeriod", std::to_string(autoRenewPeriod));
+	setCoreParameter("AutoRenewPeriod", std::to_string(autoRenewPeriod));
 }
 
 int AddNodesRequest::getPeriod()const
@@ -44,7 +44,7 @@ int AddNodesRequest::getPeriod()const
 void AddNodesRequest::setPeriod(int period)
 {
 	period_ = period;
-	setParameter("Period", std::to_string(period));
+	setCoreParameter("Period", std::to_string(period));
 }
 
 std::string AddNodesRequest::getImageId()const
@@ -55,7 +55,7 @@ std::string AddNodesRequest::getImageId()const
 void AddNodesRequest::setImageId(const std::string& imageId)
 {
 	imageId_ = imageId;
-	setParameter("ImageId", imageId);
+	setCoreParameter("ImageId", imageId);
 }
 
 int AddNodesRequest::getCount()const
@@ -66,7 +66,7 @@ int AddNodesRequest::getCount()const
 void AddNodesRequest::setCount(int count)
 {
 	count_ = count;
-	setParameter("Count", std::to_string(count));
+	setCoreParameter("Count", std::to_string(count));
 }
 
 std::string AddNodesRequest::getClusterId()const
@@ -77,7 +77,7 @@ std::string AddNodesRequest::getClusterId()const
 void AddNodesRequest::setClusterId(const std::string& clusterId)
 {
 	clusterId_ = clusterId;
-	setParameter("ClusterId", clusterId);
+	setCoreParameter("ClusterId", clusterId);
 }
 
 std::string AddNodesRequest::getComputeSpotStrategy()const
@@ -88,7 +88,7 @@ std::string AddNodesRequest::getComputeSpotStrategy()const
 void AddNodesRequest::setComputeSpotStrategy(const std::string& computeSpotStrategy)
 {
 	computeSpotStrategy_ = computeSpotStrategy;
-	setParameter("ComputeSpotStrategy", computeSpotStrategy);
+	setCoreParameter("ComputeSpotStrategy", computeSpotStrategy);
 }
 
 std::string AddNodesRequest::getJobQueue()const
@@ -99,7 +99,7 @@ std::string AddNodesRequest::getJobQueue()const
 void AddNodesRequest::setJobQueue(const std::string& jobQueue)
 {
 	jobQueue_ = jobQueue;
-	setParameter("JobQueue", jobQueue);
+	setCoreParameter("JobQueue", jobQueue);
 }
 
 std::string AddNodesRequest::getAccessKeyId()const
@@ -110,7 +110,7 @@ std::string AddNodesRequest::getAccessKeyId()const
 void AddNodesRequest::setAccessKeyId(const std::string& accessKeyId)
 {
 	accessKeyId_ = accessKeyId;
-	setParameter("AccessKeyId", accessKeyId);
+	setCoreParameter("AccessKeyId", accessKeyId);
 }
 
 std::string AddNodesRequest::getImageOwnerAlias()const
@@ -121,7 +121,18 @@ std::string AddNodesRequest::getImageOwnerAlias()const
 void AddNodesRequest::setImageOwnerAlias(const std::string& imageOwnerAlias)
 {
 	imageOwnerAlias_ = imageOwnerAlias;
-	setParameter("ImageOwnerAlias", imageOwnerAlias);
+	setCoreParameter("ImageOwnerAlias", imageOwnerAlias);
+}
+
+std::string AddNodesRequest::getVSwitchId()const
+{
+	return vSwitchId_;
+}
+
+void AddNodesRequest::setVSwitchId(const std::string& vSwitchId)
+{
+	vSwitchId_ = vSwitchId;
+	setCoreParameter("VSwitchId", vSwitchId);
 }
 
 std::string AddNodesRequest::getPeriodUnit()const
@@ -132,7 +143,7 @@ std::string AddNodesRequest::getPeriodUnit()const
 void AddNodesRequest::setPeriodUnit(const std::string& periodUnit)
 {
 	periodUnit_ = periodUnit;
-	setParameter("PeriodUnit", periodUnit);
+	setCoreParameter("PeriodUnit", periodUnit);
 }
 
 std::string AddNodesRequest::getAutoRenew()const
@@ -143,7 +154,7 @@ std::string AddNodesRequest::getAutoRenew()const
 void AddNodesRequest::setAutoRenew(const std::string& autoRenew)
 {
 	autoRenew_ = autoRenew;
-	setParameter("AutoRenew", autoRenew);
+	setCoreParameter("AutoRenew", autoRenew);
 }
 
 std::string AddNodesRequest::getEcsChargeType()const
@@ -154,7 +165,7 @@ std::string AddNodesRequest::getEcsChargeType()const
 void AddNodesRequest::setEcsChargeType(const std::string& ecsChargeType)
 {
 	ecsChargeType_ = ecsChargeType;
-	setParameter("EcsChargeType", ecsChargeType);
+	setCoreParameter("EcsChargeType", ecsChargeType);
 }
 
 std::string AddNodesRequest::getCreateMode()const
@@ -165,7 +176,18 @@ std::string AddNodesRequest::getCreateMode()const
 void AddNodesRequest::setCreateMode(const std::string& createMode)
 {
 	createMode_ = createMode;
-	setParameter("CreateMode", createMode);
+	setCoreParameter("CreateMode", createMode);
+}
+
+int AddNodesRequest::getSystemDiskSize()const
+{
+	return systemDiskSize_;
+}
+
+void AddNodesRequest::setSystemDiskSize(int systemDiskSize)
+{
+	systemDiskSize_ = systemDiskSize;
+	setCoreParameter("SystemDiskSize", std::to_string(systemDiskSize));
 }
 
 std::string AddNodesRequest::getInstanceType()const
@@ -176,7 +198,18 @@ std::string AddNodesRequest::getInstanceType()const
 void AddNodesRequest::setInstanceType(const std::string& instanceType)
 {
 	instanceType_ = instanceType;
-	setParameter("InstanceType", instanceType);
+	setCoreParameter("InstanceType", instanceType);
+}
+
+std::string AddNodesRequest::getZoneId()const
+{
+	return zoneId_;
+}
+
+void AddNodesRequest::setZoneId(const std::string& zoneId)
+{
+	zoneId_ = zoneId;
+	setCoreParameter("ZoneId", zoneId);
 }
 
 std::string AddNodesRequest::getComputeSpotPriceLimit()const
@@ -187,6 +220,6 @@ std::string AddNodesRequest::getComputeSpotPriceLimit()const
 void AddNodesRequest::setComputeSpotPriceLimit(const std::string& computeSpotPriceLimit)
 {
 	computeSpotPriceLimit_ = computeSpotPriceLimit;
-	setParameter("ComputeSpotPriceLimit", computeSpotPriceLimit);
+	setCoreParameter("ComputeSpotPriceLimit", computeSpotPriceLimit);
 }
 

ehpc/src/model/AddQueueRequest.cc

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

ehpc/src/model/AddQueueResult.cc

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

ehpc/src/model/AddUsersRequest.cc

@@ -33,7 +33,7 @@ std::string AddUsersRequest::getClusterId()const
 void AddUsersRequest::setClusterId(const std::string& clusterId)
 {
 	clusterId_ = clusterId;
-	setParameter("ClusterId", clusterId);
+	setCoreParameter("ClusterId", clusterId);
 }
 
 std::vector<AddUsersRequest::User> AddUsersRequest::getUser()const
@@ -48,9 +48,9 @@ void AddUsersRequest::setUser(const std::vector<User>& user)
 	for(int i = 0; i!= user.size(); i++)	{
 		auto obj = user.at(i);
 		std::string str ="User."+ std::to_string(i);
-		setParameter(str + ".Password", obj.password);
-		setParameter(str + ".Name", obj.name);
-		setParameter(str + ".Group", obj.group);
+		setCoreParameter(str + ".Password", obj.password);
+		setCoreParameter(str + ".Name", obj.name);
+		setCoreParameter(str + ".Group", obj.group);
 	}
 }
 
@@ -62,6 +62,6 @@ std::string AddUsersRequest::getAccessKeyId()const
 void AddUsersRequest::setAccessKeyId(const std::string& accessKeyId)
 {
 	accessKeyId_ = accessKeyId;
-	setParameter("AccessKeyId", accessKeyId);
+	setCoreParameter("AccessKeyId", accessKeyId);
 }
 

ehpc/src/model/CreateClusterRequest.cc

@@ -33,7 +33,7 @@ std::string CreateClusterRequest::getSccClusterId()const
 void CreateClusterRequest::setSccClusterId(const std::string& sccClusterId)
 {
 	sccClusterId_ = sccClusterId;
-	setParameter("SccClusterId", sccClusterId);
+	setCoreParameter("SccClusterId", sccClusterId);
 }
 
 std::string CreateClusterRequest::getImageId()const
@@ -44,7 +44,31 @@ std::string CreateClusterRequest::getImageId()const
 void CreateClusterRequest::setImageId(const std::string& imageId)
 {
 	imageId_ = imageId;
-	setParameter("ImageId", imageId);
+	setCoreParameter("ImageId", imageId);
+}
+
+std::vector<CreateClusterRequest::AdditionalVolumes> CreateClusterRequest::getAdditionalVolumes()const
+{
+	return additionalVolumes_;
+}
+
+void CreateClusterRequest::setAdditionalVolumes(const std::vector<AdditionalVolumes>& additionalVolumes)
+{
+	additionalVolumes_ = additionalVolumes;
+	int i = 0;
+	for(int i = 0; i!= additionalVolumes.size(); i++)	{
+		auto obj = additionalVolumes.at(i);
+		std::string str ="AdditionalVolumes."+ std::to_string(i);
+		setCoreParameter(str + ".VolumeType", obj.volumeType);
+		setCoreParameter(str + ".VolumeProtocol", obj.volumeProtocol);
+		setCoreParameter(str + ".LocalDirectory", obj.localDirectory);
+		setCoreParameter(str + ".RemoteDirectory", obj.remoteDirectory);
+		setCoreParameter(str + ".Roles", std::to_string(obj.roles));
+		setCoreParameter(str + ".VolumeId", obj.volumeId);
+		setCoreParameter(str + ".VolumeMountpoint", obj.volumeMountpoint);
+		setCoreParameter(str + ".Location", obj.location);
+		setCoreParameter(str + ".JobQueue", obj.jobQueue);
+	}
 }
 
 std::string CreateClusterRequest::getEcsOrderManagerInstanceType()const
@@ -55,7 +79,7 @@ std::string CreateClusterRequest::getEcsOrderManagerInstanceType()const
 void CreateClusterRequest::setEcsOrderManagerInstanceType(const std::string& ecsOrderManagerInstanceType)
 {
 	ecsOrderManagerInstanceType_ = ecsOrderManagerInstanceType;
-	setParameter("EcsOrderManagerInstanceType", ecsOrderManagerInstanceType);
+	setCoreParameter("EcsOrderManagerInstanceType", ecsOrderManagerInstanceType);
 }
 
 std::string CreateClusterRequest::getEhpcVersion()const
@@ -66,7 +90,7 @@ std::string CreateClusterRequest::getEhpcVersion()const
 void CreateClusterRequest::setEhpcVersion(const std::string& ehpcVersion)
 {
 	ehpcVersion_ = ehpcVersion;
-	setParameter("EhpcVersion", ehpcVersion);
+	setCoreParameter("EhpcVersion", ehpcVersion);
 }
 
 std::string CreateClusterRequest::getAccountType()const
@@ -77,7 +101,7 @@ std::string CreateClusterRequest::getAccountType()const
 void CreateClusterRequest::setAccountType(const std::string& accountType)
 {
 	accountType_ = accountType;
-	setParameter("AccountType", accountType);
+	setCoreParameter("AccountType", accountType);
 }
 
 std::string CreateClusterRequest::getSecurityGroupId()const
@@ -88,7 +112,7 @@ std::string CreateClusterRequest::getSecurityGroupId()const
 void CreateClusterRequest::setSecurityGroupId(const std::string& securityGroupId)
 {
 	securityGroupId_ = securityGroupId;
-	setParameter("SecurityGroupId", securityGroupId);
+	setCoreParameter("SecurityGroupId", securityGroupId);
 }
 
 std::string CreateClusterRequest::getDescription()const
@@ -99,7 +123,7 @@ std::string CreateClusterRequest::getDescription()const
 void CreateClusterRequest::setDescription(const std::string& description)
 {
 	description_ = description;
-	setParameter("Description", description);
+	setCoreParameter("Description", description);
 }
 
 std::string CreateClusterRequest::getKeyPairName()const
@@ -110,7 +134,7 @@ std::string CreateClusterRequest::getKeyPairName()const
 void CreateClusterRequest::setKeyPairName(const std::string& keyPairName)
 {
 	keyPairName_ = keyPairName;
-	setParameter("KeyPairName", keyPairName);
+	setCoreParameter("KeyPairName", keyPairName);
 }
 
 std::string CreateClusterRequest::getSecurityGroupName()const
@@ -121,7 +145,7 @@ std::string CreateClusterRequest::getSecurityGroupName()const
 void CreateClusterRequest::setSecurityGroupName(const std::string& securityGroupName)
 {
 	securityGroupName_ = securityGroupName;
-	setParameter("SecurityGroupName", securityGroupName);
+	setCoreParameter("SecurityGroupName", securityGroupName);
 }
 
 std::string CreateClusterRequest::getEcsOrderComputeInstanceType()const
@@ -132,7 +156,7 @@ std::string CreateClusterRequest::getEcsOrderComputeInstanceType()const
 void CreateClusterRequest::setEcsOrderComputeInstanceType(const std::string& ecsOrderComputeInstanceType)
 {
 	ecsOrderComputeInstanceType_ = ecsOrderComputeInstanceType;
-	setParameter("EcsOrderComputeInstanceType", ecsOrderComputeInstanceType);
+	setCoreParameter("EcsOrderComputeInstanceType", ecsOrderComputeInstanceType);
 }
 
 std::string CreateClusterRequest::getJobQueue()const
@@ -143,7 +167,7 @@ std::string CreateClusterRequest::getJobQueue()const
 void CreateClusterRequest::setJobQueue(const std::string& jobQueue)
 {
 	jobQueue_ = jobQueue;
-	setParameter("JobQueue", jobQueue);
+	setCoreParameter("JobQueue", jobQueue);
 }
 
 std::string CreateClusterRequest::getAccessKeyId()const
@@ -154,7 +178,7 @@ std::string CreateClusterRequest::getAccessKeyId()const
 void CreateClusterRequest::setAccessKeyId(const std::string& accessKeyId)
 {
 	accessKeyId_ = accessKeyId;
-	setParameter("AccessKeyId", accessKeyId);
+	setCoreParameter("AccessKeyId", accessKeyId);
 }
 
 std::string CreateClusterRequest::getImageOwnerAlias()const
@@ -165,7 +189,7 @@ std::string CreateClusterRequest::getImageOwnerAlias()const
 void CreateClusterRequest::setImageOwnerAlias(const std::string& imageOwnerAlias)
 {
 	imageOwnerAlias_ = imageOwnerAlias;
-	setParameter("ImageOwnerAlias", imageOwnerAlias);
+	setCoreParameter("ImageOwnerAlias", imageOwnerAlias);
 }
 
 std::string CreateClusterRequest::getVolumeType()const
@@ -176,7 +200,7 @@ std::string CreateClusterRequest::getVolumeType()const
 void CreateClusterRequest::setVolumeType(const std::string& volumeType)
 {
 	volumeType_ = volumeType;
-	setParameter("VolumeType", volumeType);
+	setCoreParameter("VolumeType", volumeType);
 }
 
 std::string CreateClusterRequest::getDeployMode()const
@@ -187,7 +211,7 @@ std::string CreateClusterRequest::getDeployMode()const
 void CreateClusterRequest::setDeployMode(const std::string& deployMode)
 {
 	deployMode_ = deployMode;
-	setParameter("DeployMode", deployMode);
+	setCoreParameter("DeployMode", deployMode);
 }
 
 int CreateClusterRequest::getEcsOrderManagerCount()const
@@ -198,7 +222,18 @@ int CreateClusterRequest::getEcsOrderManagerCount()const
 void CreateClusterRequest::setEcsOrderManagerCount(int ecsOrderManagerCount)
 {
 	ecsOrderManagerCount_ = ecsOrderManagerCount;
-	setParameter("EcsOrderManagerCount", std::to_string(ecsOrderManagerCount));
+	setCoreParameter("EcsOrderManagerCount", std::to_string(ecsOrderManagerCount));
+}
+
+std::string CreateClusterRequest::getResourceGroupId()const
+{
+	return resourceGroupId_;
+}
+
+void CreateClusterRequest::setResourceGroupId(const std::string& resourceGroupId)
+{
+	resourceGroupId_ = resourceGroupId;
+	setCoreParameter("ResourceGroupId", resourceGroupId);
 }
 
 std::string CreateClusterRequest::getPassword()const
@@ -209,7 +244,7 @@ std::string CreateClusterRequest::getPassword()const
 void CreateClusterRequest::setPassword(const std::string& password)
 {
 	password_ = password;
-	setParameter("Password", password);
+	setCoreParameter("Password", password);
 }
 
 int CreateClusterRequest::getEcsOrderLoginCount()const
@@ -220,7 +255,29 @@ int CreateClusterRequest::getEcsOrderLoginCount()const
 void CreateClusterRequest::setEcsOrderLoginCount(int ecsOrderLoginCount)
 {
 	ecsOrderLoginCount_ = ecsOrderLoginCount;
-	setParameter("EcsOrderLoginCount", std::to_string(ecsOrderLoginCount));
+	setCoreParameter("EcsOrderLoginCount", std::to_string(ecsOrderLoginCount));
+}
+
+std::string CreateClusterRequest::getRemoteVisEnable()const
+{
+	return remoteVisEnable_;
+}
+
+void CreateClusterRequest::setRemoteVisEnable(const std::string& remoteVisEnable)
+{
+	remoteVisEnable_ = remoteVisEnable;
+	setCoreParameter("RemoteVisEnable", remoteVisEnable);
+}
+
+int CreateClusterRequest::getSystemDiskSize()const
+{
+	return systemDiskSize_;
+}
+
+void CreateClusterRequest::setSystemDiskSize(int systemDiskSize)
+{
+	systemDiskSize_ = systemDiskSize;
+	setCoreParameter("SystemDiskSize", std::to_string(systemDiskSize));
 }
 
 std::string CreateClusterRequest::getComputeSpotPriceLimit()const
@@ -231,7 +288,7 @@ std::string CreateClusterRequest::getComputeSpotPriceLimit()const
 void CreateClusterRequest::setComputeSpotPriceLimit(const std::string& computeSpotPriceLimit)
 {
 	computeSpotPriceLimit_ = computeSpotPriceLimit;
-	setParameter("ComputeSpotPriceLimit", computeSpotPriceLimit);
+	setCoreParameter("ComputeSpotPriceLimit", computeSpotPriceLimit);
 }
 
 int CreateClusterRequest::getAutoRenewPeriod()const
@@ -242,7 +299,7 @@ int CreateClusterRequest::getAutoRenewPeriod()const
 void CreateClusterRequest::setAutoRenewPeriod(int autoRenewPeriod)
 {
 	autoRenewPeriod_ = autoRenewPeriod;
-	setParameter("AutoRenewPeriod", std::to_string(autoRenewPeriod));
+	setCoreParameter("AutoRenewPeriod", std::to_string(autoRenewPeriod));
 }
 
 int CreateClusterRequest::getPeriod()const
@@ -253,7 +310,7 @@ int CreateClusterRequest::getPeriod()const
 void CreateClusterRequest::setPeriod(int period)
 {
 	period_ = period;
-	setParameter("Period", std::to_string(period));
+	setCoreParameter("Period", std::to_string(period));
 }
 
 std::string CreateClusterRequest::getVolumeProtocol()const
@@ -264,7 +321,7 @@ std::string CreateClusterRequest::getVolumeProtocol()const
 void CreateClusterRequest::setVolumeProtocol(const std::string& volumeProtocol)
 {
 	volumeProtocol_ = volumeProtocol;
-	setParameter("VolumeProtocol", volumeProtocol);
+	setCoreParameter("VolumeProtocol", volumeProtocol);
 }
 
 std::string CreateClusterRequest::getClientVersion()const
@@ -275,7 +332,7 @@ std::string CreateClusterRequest::getClientVersion()const
 void CreateClusterRequest::setClientVersion(const std::string& clientVersion)
 {
 	clientVersion_ = clientVersion;
-	setParameter("ClientVersion", clientVersion);
+	setCoreParameter("ClientVersion", clientVersion);
 }
 
 std::string CreateClusterRequest::getOsTag()const
@@ -286,7 +343,7 @@ std::string CreateClusterRequest::getOsTag()const
 void CreateClusterRequest::setOsTag(const std::string& osTag)
 {
 	osTag_ = osTag;
-	setParameter("OsTag", osTag);
+	setCoreParameter("OsTag", osTag);
 }
 
 std::string CreateClusterRequest::getRemoteDirectory()const
@@ -297,7 +354,7 @@ std::string CreateClusterRequest::getRemoteDirectory()const
 void CreateClusterRequest::setRemoteDirectory(const std::string& remoteDirectory)
 {
 	remoteDirectory_ = remoteDirectory;
-	setParameter("RemoteDirectory", remoteDirectory);
+	setCoreParameter("RemoteDirectory", remoteDirectory);
 }
 
 int CreateClusterRequest::getEcsOrderComputeCount()const
@@ -308,7 +365,7 @@ int CreateClusterRequest::getEcsOrderComputeCount()const
 void CreateClusterRequest::setEcsOrderComputeCount(int ecsOrderComputeCount)
 {
 	ecsOrderComputeCount_ = ecsOrderComputeCount;
-	setParameter("EcsOrderComputeCount", std::to_string(ecsOrderComputeCount));
+	setCoreParameter("EcsOrderComputeCount", std::to_string(ecsOrderComputeCount));
 }
 
 std::string CreateClusterRequest::getComputeSpotStrategy()const
@@ -319,7 +376,7 @@ std::string CreateClusterRequest::getComputeSpotStrategy()const
 void CreateClusterRequest::setComputeSpotStrategy(const std::string& computeSpotStrategy)
 {
 	computeSpotStrategy_ = computeSpotStrategy;
-	setParameter("ComputeSpotStrategy", computeSpotStrategy);
+	setCoreParameter("ComputeSpotStrategy", computeSpotStrategy);
 }
 
 std::vector<CreateClusterRequest::PostInstallScript> CreateClusterRequest::getPostInstallScript()const
@@ -334,8 +391,8 @@ void CreateClusterRequest::setPostInstallScript(const std::vector<PostInstallScr
 	for(int i = 0; i!= postInstallScript.size(); i++)	{
 		auto obj = postInstallScript.at(i);
 		std::string str ="PostInstallScript."+ std::to_string(i);
-		setParameter(str + ".Args", obj.args);
-		setParameter(str + ".Url", obj.url);
+		setCoreParameter(str + ".Args", obj.args);
+		setCoreParameter(str + ".Url", obj.url);
 	}
 }
 
@@ -347,7 +404,7 @@ std::string CreateClusterRequest::getVSwitchId()const
 void CreateClusterRequest::setVSwitchId(const std::string& vSwitchId)
 {
 	vSwitchId_ = vSwitchId;
-	setParameter("VSwitchId", vSwitchId);
+	setCoreParameter("VSwitchId", vSwitchId);
 }
 
 std::string CreateClusterRequest::getPeriodUnit()const
@@ -358,7 +415,7 @@ std::string CreateClusterRequest::getPeriodUnit()const
 void CreateClusterRequest::setPeriodUnit(const std::string& periodUnit)
 {
 	periodUnit_ = periodUnit;
-	setParameter("PeriodUnit", periodUnit);
+	setCoreParameter("PeriodUnit", periodUnit);
 }
 
 std::vector<CreateClusterRequest::Application> CreateClusterRequest::getApplication()const
@@ -373,7 +430,7 @@ void CreateClusterRequest::setApplication(const std::vector<Application>& applic
 	for(int i = 0; i!= application.size(); i++)	{
 		auto obj = application.at(i);
 		std::string str ="Application."+ std::to_string(i);
-		setParameter(str + ".Tag", obj.tag);
+		setCoreParameter(str + ".Tag", obj.tag);
 	}
 }
 
@@ -385,7 +442,7 @@ std::string CreateClusterRequest::getAutoRenew()const
 void CreateClusterRequest::setAutoRenew(const std::string& autoRenew)
 {
 	autoRenew_ = autoRenew;
-	setParameter("AutoRenew", autoRenew);
+	setCoreParameter("AutoRenew", autoRenew);
 }
 
 std::string CreateClusterRequest::getEcsChargeType()const
@@ -396,7 +453,7 @@ std::string CreateClusterRequest::getEcsChargeType()const
 void CreateClusterRequest::setEcsChargeType(const std::string& ecsChargeType)
 {
 	ecsChargeType_ = ecsChargeType;
-	setParameter("EcsChargeType", ecsChargeType);
+	setCoreParameter("EcsChargeType", ecsChargeType);
 }
 
 std::string CreateClusterRequest::getInputFileUrl()const
@@ -407,7 +464,7 @@ std::string CreateClusterRequest::getInputFileUrl()const
 void CreateClusterRequest::setInputFileUrl(const std::string& inputFileUrl)
 {
 	inputFileUrl_ = inputFileUrl;
-	setParameter("InputFileUrl", inputFileUrl);
+	setCoreParameter("InputFileUrl", inputFileUrl);
 }
 
 std::string CreateClusterRequest::getVpcId()const
@@ -418,7 +475,7 @@ std::string CreateClusterRequest::getVpcId()const
 void CreateClusterRequest::setVpcId(const std::string& vpcId)
 {
 	vpcId_ = vpcId;
-	setParameter("VpcId", vpcId);
+	setCoreParameter("VpcId", vpcId);
 }
 
 bool CreateClusterRequest::getHaEnable()const
@@ -429,7 +486,7 @@ bool CreateClusterRequest::getHaEnable()const
 void CreateClusterRequest::setHaEnable(bool haEnable)
 {
 	haEnable_ = haEnable;
-	setParameter("HaEnable", std::to_string(haEnable));
+	setCoreParameter("HaEnable", haEnable ? "true" : "false");
 }
 
 std::string CreateClusterRequest::getName()const
@@ -440,7 +497,7 @@ std::string CreateClusterRequest::getName()const
 void CreateClusterRequest::setName(const std::string& name)
 {
 	name_ = name;
-	setParameter("Name", name);
+	setCoreParameter("Name", name);
 }
 
 std::string CreateClusterRequest::getSchedulerType()const
@@ -451,7 +508,7 @@ std::string CreateClusterRequest::getSchedulerType()const
 void CreateClusterRequest::setSchedulerType(const std::string& schedulerType)
 {
 	schedulerType_ = schedulerType;
-	setParameter("SchedulerType", schedulerType);
+	setCoreParameter("SchedulerType", schedulerType);
 }
 
 std::string CreateClusterRequest::getVolumeId()const
@@ -462,7 +519,7 @@ std::string CreateClusterRequest::getVolumeId()const
 void CreateClusterRequest::setVolumeId(const std::string& volumeId)
 {
 	volumeId_ = volumeId;
-	setParameter("VolumeId", volumeId);
+	setCoreParameter("VolumeId", volumeId);
 }
 
 std::string CreateClusterRequest::getVolumeMountpoint()const
@@ -473,7 +530,7 @@ std::string CreateClusterRequest::getVolumeMountpoint()const
 void CreateClusterRequest::setVolumeMountpoint(const std::string& volumeMountpoint)
 {
 	volumeMountpoint_ = volumeMountpoint;
-	setParameter("VolumeMountpoint", volumeMountpoint);
+	setCoreParameter("VolumeMountpoint", volumeMountpoint);
 }
 
 std::string CreateClusterRequest::getEcsOrderLoginInstanceType()const
@@ -484,7 +541,7 @@ std::string CreateClusterRequest::getEcsOrderLoginInstanceType()const
 void CreateClusterRequest::setEcsOrderLoginInstanceType(const std::string& ecsOrderLoginInstanceType)
 {
 	ecsOrderLoginInstanceType_ = ecsOrderLoginInstanceType;
-	setParameter("EcsOrderLoginInstanceType", ecsOrderLoginInstanceType);
+	setCoreParameter("EcsOrderLoginInstanceType", ecsOrderLoginInstanceType);
 }
 
 std::string CreateClusterRequest::getZoneId()const
@@ -495,6 +552,6 @@ std::string CreateClusterRequest::getZoneId()const
 void CreateClusterRequest::setZoneId(const std::string& zoneId)
 {
 	zoneId_ = zoneId;
-	setParameter("ZoneId", zoneId);
+	setCoreParameter("ZoneId", zoneId);
 }
 

ehpc/src/model/CreateHybridClusterRequest.cc

@@ -33,7 +33,7 @@ std::string CreateHybridClusterRequest::getEhpcVersion()const
 void CreateHybridClusterRequest::setEhpcVersion(const std::string& ehpcVersion)
 {
 	ehpcVersion_ = ehpcVersion;
-	setParameter("EhpcVersion", ehpcVersion);
+	setCoreParameter("EhpcVersion", ehpcVersion);
 }
 
 std::string CreateHybridClusterRequest::getSecurityGroupId()const
@@ -44,7 +44,7 @@ std::string CreateHybridClusterRequest::getSecurityGroupId()const
 void CreateHybridClusterRequest::setSecurityGroupId(const std::string& securityGroupId)
 {
 	securityGroupId_ = securityGroupId;
-	setParameter("SecurityGroupId", securityGroupId);
+	setCoreParameter("SecurityGroupId", securityGroupId);
 }
 
 std::string CreateHybridClusterRequest::getDescription()const
@@ -55,7 +55,7 @@ std::string CreateHybridClusterRequest::getDescription()const
 void CreateHybridClusterRequest::setDescription(const std::string& description)
 {
 	description_ = description;
-	setParameter("Description", description);
+	setCoreParameter("Description", description);
 }
 
 std::string CreateHybridClusterRequest::getKeyPairName()const
@@ -66,7 +66,7 @@ std::string CreateHybridClusterRequest::getKeyPairName()const
 void CreateHybridClusterRequest::setKeyPairName(const std::string& keyPairName)
 {
 	keyPairName_ = keyPairName;
-	setParameter("KeyPairName", keyPairName);
+	setCoreParameter("KeyPairName", keyPairName);
 }
 
 std::string CreateHybridClusterRequest::getSecurityGroupName()const
@@ -77,7 +77,7 @@ std::string CreateHybridClusterRequest::getSecurityGroupName()const
 void CreateHybridClusterRequest::setSecurityGroupName(const std::string& securityGroupName)
 {
 	securityGroupName_ = securityGroupName;
-	setParameter("SecurityGroupName", securityGroupName);
+	setCoreParameter("SecurityGroupName", securityGroupName);
 }
 
 std::string CreateHybridClusterRequest::getEcsOrderComputeInstanceType()const
@@ -88,7 +88,7 @@ std::string CreateHybridClusterRequest::getEcsOrderComputeInstanceType()const
 void CreateHybridClusterRequest::setEcsOrderComputeInstanceType(const std::string& ecsOrderComputeInstanceType)
 {
 	ecsOrderComputeInstanceType_ = ecsOrderComputeInstanceType;
-	setParameter("EcsOrderComputeInstanceType", ecsOrderComputeInstanceType);
+	setCoreParameter("EcsOrderComputeInstanceType", ecsOrderComputeInstanceType);
 }
 
 std::string CreateHybridClusterRequest::getOnPremiseVolumeRemotePath()const
@@ -99,7 +99,7 @@ std::string CreateHybridClusterRequest::getOnPremiseVolumeRemotePath()const
 void CreateHybridClusterRequest::setOnPremiseVolumeRemotePath(const std::string& onPremiseVolumeRemotePath)
 {
 	onPremiseVolumeRemotePath_ = onPremiseVolumeRemotePath;
-	setParameter("OnPremiseVolumeRemotePath", onPremiseVolumeRemotePath);
+	setCoreParameter("OnPremiseVolumeRemotePath", onPremiseVolumeRemotePath);
 }
 
 std::string CreateHybridClusterRequest::getJobQueue()const
@@ -110,7 +110,7 @@ std::string CreateHybridClusterRequest::getJobQueue()const
 void CreateHybridClusterRequest::setJobQueue(const std::string& jobQueue)
 {
 	jobQueue_ = jobQueue;
-	setParameter("JobQueue", jobQueue);
+	setCoreParameter("JobQueue", jobQueue);
 }
 
 std::string CreateHybridClusterRequest::getAccessKeyId()const
@@ -121,7 +121,7 @@ std::string CreateHybridClusterRequest::getAccessKeyId()const
 void CreateHybridClusterRequest::setAccessKeyId(const std::string& accessKeyId)
 {
 	accessKeyId_ = accessKeyId;
-	setParameter("AccessKeyId", accessKeyId);
+	setCoreParameter("AccessKeyId", accessKeyId);
 }
 
 std::string CreateHybridClusterRequest::getVolumeType()const
@@ -132,7 +132,18 @@ std::string CreateHybridClusterRequest::getVolumeType()const
 void CreateHybridClusterRequest::setVolumeType(const std::string& volumeType)
 {
 	volumeType_ = volumeType;
-	setParameter("VolumeType", volumeType);
+	setCoreParameter("VolumeType", volumeType);
+}
+
+std::string CreateHybridClusterRequest::getResourceGroupId()const
+{
+	return resourceGroupId_;
+}
+
+void CreateHybridClusterRequest::setResourceGroupId(const std::string& resourceGroupId)
+{
+	resourceGroupId_ = resourceGroupId;
+	setCoreParameter("ResourceGroupId", resourceGroupId);
 }
 
 std::string CreateHybridClusterRequest::getPassword()const
@@ -143,7 +154,7 @@ std::string CreateHybridClusterRequest::getPassword()const
 void CreateHybridClusterRequest::setPassword(const std::string& password)
 {
 	password_ = password;
-	setParameter("Password", password);
+	setCoreParameter("Password", password);
 }
 
 std::string CreateHybridClusterRequest::getOnPremiseVolumeMountPoint()const
@@ -154,7 +165,7 @@ std::string CreateHybridClusterRequest::getOnPremiseVolumeMountPoint()const
 void CreateHybridClusterRequest::setOnPremiseVolumeMountPoint(const std::string& onPremiseVolumeMountPoint)
 {
 	onPremiseVolumeMountPoint_ = onPremiseVolumeMountPoint;
-	setParameter("OnPremiseVolumeMountPoint", onPremiseVolumeMountPoint);
+	setCoreParameter("OnPremiseVolumeMountPoint", onPremiseVolumeMountPoint);
 }
 
 std::string CreateHybridClusterRequest::getOnPremiseVolumeProtocol()const
@@ -165,7 +176,7 @@ std::string CreateHybridClusterRequest::getOnPremiseVolumeProtocol()const
 void CreateHybridClusterRequest::setOnPremiseVolumeProtocol(const std::string& onPremiseVolumeProtocol)
 {
 	onPremiseVolumeProtocol_ = onPremiseVolumeProtocol;
-	setParameter("OnPremiseVolumeProtocol", onPremiseVolumeProtocol);
+	setCoreParameter("OnPremiseVolumeProtocol", onPremiseVolumeProtocol);
 }
 
 std::string CreateHybridClusterRequest::getVolumeProtocol()const
@@ -176,7 +187,7 @@ std::string CreateHybridClusterRequest::getVolumeProtocol()const
 void CreateHybridClusterRequest::setVolumeProtocol(const std::string& volumeProtocol)
 {
 	volumeProtocol_ = volumeProtocol;
-	setParameter("VolumeProtocol", volumeProtocol);
+	setCoreParameter("VolumeProtocol", volumeProtocol);
 }
 
 std::string CreateHybridClusterRequest::getOnPremiseVolumeLocalPath()const
@@ -187,7 +198,7 @@ std::string CreateHybridClusterRequest::getOnPremiseVolumeLocalPath()const
 void CreateHybridClusterRequest::setOnPremiseVolumeLocalPath(const std::string& onPremiseVolumeLocalPath)
 {
 	onPremiseVolumeLocalPath_ = onPremiseVolumeLocalPath;
-	setParameter("OnPremiseVolumeLocalPath", onPremiseVolumeLocalPath);
+	setCoreParameter("OnPremiseVolumeLocalPath", onPremiseVolumeLocalPath);
 }
 
 std::string CreateHybridClusterRequest::getClientVersion()const
@@ -198,7 +209,7 @@ std::string CreateHybridClusterRequest::getClientVersion()const
 void CreateHybridClusterRequest::setClientVersion(const std::string& clientVersion)
 {
 	clientVersion_ = clientVersion;
-	setParameter("ClientVersion", clientVersion);
+	setCoreParameter("ClientVersion", clientVersion);
 }
 
 std::string CreateHybridClusterRequest::getOsTag()const
@@ -209,7 +220,7 @@ std::string CreateHybridClusterRequest::getOsTag()const
 void CreateHybridClusterRequest::setOsTag(const std::string& osTag)
 {
 	osTag_ = osTag;
-	setParameter("OsTag", osTag);
+	setCoreParameter("OsTag", osTag);
 }
 
 std::string CreateHybridClusterRequest::getRemoteDirectory()const
@@ -220,7 +231,7 @@ std::string CreateHybridClusterRequest::getRemoteDirectory()const
 void CreateHybridClusterRequest::setRemoteDirectory(const std::string& remoteDirectory)
 {
 	remoteDirectory_ = remoteDirectory;
-	setParameter("RemoteDirectory", remoteDirectory);
+	setCoreParameter("RemoteDirectory", remoteDirectory);
 }
 
 std::vector<CreateHybridClusterRequest::PostInstallScript> CreateHybridClusterRequest::getPostInstallScript()const
@@ -235,8 +246,8 @@ void CreateHybridClusterRequest::setPostInstallScript(const std::vector<PostInst
 	for(int i = 0; i!= postInstallScript.size(); i++)	{
 		auto obj = postInstallScript.at(i);
 		std::string str ="PostInstallScript."+ std::to_string(i);
-		setParameter(str + ".Args", obj.args);
-		setParameter(str + ".Url", obj.url);
+		setCoreParameter(str + ".Args", obj.args);
+		setCoreParameter(str + ".Url", obj.url);
 	}
 }
 
@@ -248,7 +259,7 @@ std::string CreateHybridClusterRequest::getVSwitchId()const
 void CreateHybridClusterRequest::setVSwitchId(const std::string& vSwitchId)
 {
 	vSwitchId_ = vSwitchId;
-	setParameter("VSwitchId", vSwitchId);
+	setCoreParameter("VSwitchId", vSwitchId);
 }
 
 std::string CreateHybridClusterRequest::getNodes()const
@@ -259,7 +270,7 @@ std::string CreateHybridClusterRequest::getNodes()const
 void CreateHybridClusterRequest::setNodes(const std::string& nodes)
 {
 	nodes_ = nodes;
-	setParameter("Nodes", nodes);
+	setCoreParameter("Nodes", nodes);
 }
 
 std::vector<CreateHybridClusterRequest::Application> CreateHybridClusterRequest::getApplication()const
@@ -274,7 +285,7 @@ void CreateHybridClusterRequest::setApplication(const std::vector<Application>&
 	for(int i = 0; i!= application.size(); i++)	{
 		auto obj = application.at(i);
 		std::string str ="Application."+ std::to_string(i);
-		setParameter(str + ".Tag", obj.tag);
+		setCoreParameter(str + ".Tag", obj.tag);
 	}
 }
 
@@ -286,7 +297,7 @@ std::string CreateHybridClusterRequest::getDomain()const
 void CreateHybridClusterRequest::setDomain(const std::string& domain)
 {
 	domain_ = domain;
-	setParameter("Domain", domain);
+	setCoreParameter("Domain", domain);
 }
 
 std::string CreateHybridClusterRequest::getVpcId()const
@@ -297,7 +308,7 @@ std::string CreateHybridClusterRequest::getVpcId()const
 void CreateHybridClusterRequest::setVpcId(const std::string& vpcId)
 {
 	vpcId_ = vpcId;
-	setParameter("VpcId", vpcId);
+	setCoreParameter("VpcId", vpcId);
 }
 
 std::string CreateHybridClusterRequest::getName()const
@@ -308,7 +319,7 @@ std::string CreateHybridClusterRequest::getName()const
 void CreateHybridClusterRequest::setName(const std::string& name)
 {
 	name_ = name;
-	setParameter("Name", name);
+	setCoreParameter("Name", name);
 }
 
 std::string CreateHybridClusterRequest::getVolumeId()const
@@ -319,7 +330,7 @@ std::string CreateHybridClusterRequest::getVolumeId()const
 void CreateHybridClusterRequest::setVolumeId(const std::string& volumeId)
 {
 	volumeId_ = volumeId;
-	setParameter("VolumeId", volumeId);
+	setCoreParameter("VolumeId", volumeId);
 }
 
 std::string CreateHybridClusterRequest::getVolumeMountpoint()const
@@ -330,7 +341,7 @@ std::string CreateHybridClusterRequest::getVolumeMountpoint()const
 void CreateHybridClusterRequest::setVolumeMountpoint(const std::string& volumeMountpoint)
 {
 	volumeMountpoint_ = volumeMountpoint;
-	setParameter("VolumeMountpoint", volumeMountpoint);
+	setCoreParameter("VolumeMountpoint", volumeMountpoint);
 }
 
 std::string CreateHybridClusterRequest::getZoneId()const
@@ -341,7 +352,7 @@ std::string CreateHybridClusterRequest::getZoneId()const
 void CreateHybridClusterRequest::setZoneId(const std::string& zoneId)
 {
 	zoneId_ = zoneId;
-	setParameter("ZoneId", zoneId);
+	setCoreParameter("ZoneId", zoneId);
 }
 
 std::string CreateHybridClusterRequest::getLocation()const
@@ -352,6 +363,6 @@ std::string CreateHybridClusterRequest::getLocation()const
 void CreateHybridClusterRequest::setLocation(const std::string& location)
 {
 	location_ = location;
-	setParameter("Location", location);
+	setCoreParameter("Location", location);
 }
 

ehpc/src/model/CreateJobFileRequest.cc

@@ -0,0 +1,93 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/ehpc/model/CreateJobFileRequest.h>
+
+using AlibabaCloud::EHPC::Model::CreateJobFileRequest;
+
+CreateJobFileRequest::CreateJobFileRequest() :
+	RpcServiceRequest("ehpc", "2018-04-12", "CreateJobFile")
+{}
+
+CreateJobFileRequest::~CreateJobFileRequest()
+{}
+
+std::string CreateJobFileRequest::getTargetFile()const
+{
+	return targetFile_;
+}
+
+void CreateJobFileRequest::setTargetFile(const std::string& targetFile)
+{
+	targetFile_ = targetFile;
+	setCoreParameter("TargetFile", targetFile);
+}
+
+std::string CreateJobFileRequest::getRunasUserPassword()const
+{
+	return runasUserPassword_;
+}
+
+void CreateJobFileRequest::setRunasUserPassword(const std::string& runasUserPassword)
+{
+	runasUserPassword_ = runasUserPassword;
+	setCoreParameter("RunasUserPassword", runasUserPassword);
+}
+
+std::string CreateJobFileRequest::getRunasUser()const
+{
+	return runasUser_;
+}
+
+void CreateJobFileRequest::setRunasUser(const std::string& runasUser)
+{
+	runasUser_ = runasUser;
+	setCoreParameter("RunasUser", runasUser);
+}
+
+std::string CreateJobFileRequest::getClusterId()const
+{
+	return clusterId_;
+}
+
+void CreateJobFileRequest::setClusterId(const std::string& clusterId)
+{
+	clusterId_ = clusterId;
+	setCoreParameter("ClusterId", clusterId);
+}
+
+std::string CreateJobFileRequest::getContent()const
+{
+	return content_;
+}
+
+void CreateJobFileRequest::setContent(const std::string& content)
+{
+	content_ = content;
+	setCoreParameter("Content", content);
+}
+
+std::string CreateJobFileRequest::getAccessKeyId()const
+{
+	return accessKeyId_;
+}
+
+void CreateJobFileRequest::setAccessKeyId(const std::string& accessKeyId)
+{
+	accessKeyId_ = accessKeyId;
+	setCoreParameter("AccessKeyId", accessKeyId);
+}
+

ehpc/src/model/CreateJobFileResult.cc

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

ehpc/src/model/CreateJobTemplateRequest.cc

@@ -33,7 +33,7 @@ std::string CreateJobTemplateRequest::getStderrRedirectPath()const
 void CreateJobTemplateRequest::setStderrRedirectPath(const std::string& stderrRedirectPath)
 {
 	stderrRedirectPath_ = stderrRedirectPath;
-	setParameter("StderrRedirectPath", stderrRedirectPath);
+	setCoreParameter("StderrRedirectPath", stderrRedirectPath);
 }
 
 std::string CreateJobTemplateRequest::getArrayRequest()const
@@ -44,7 +44,7 @@ std::string CreateJobTemplateRequest::getArrayRequest()const
 void CreateJobTemplateRequest::setArrayRequest(const std::string& arrayRequest)
 {
 	arrayRequest_ = arrayRequest;
-	setParameter("ArrayRequest", arrayRequest);
+	setCoreParameter("ArrayRequest", arrayRequest);
 }
 
 std::string CreateJobTemplateRequest::getPackagePath()const
@@ -55,7 +55,7 @@ std::string CreateJobTemplateRequest::getPackagePath()const
 void CreateJobTemplateRequest::setPackagePath(const std::string& packagePath)
 {
 	packagePath_ = packagePath;
-	setParameter("PackagePath", packagePath);
+	setCoreParameter("PackagePath", packagePath);
 }
 
 std::string CreateJobTemplateRequest::getVariables()const
@@ -66,7 +66,7 @@ std::string CreateJobTemplateRequest::getVariables()const
 void CreateJobTemplateRequest::setVariables(const std::string& variables)
 {
 	variables_ = variables;
-	setParameter("Variables", variables);
+	setCoreParameter("Variables", variables);
 }
 
 std::string CreateJobTemplateRequest::getName()const
@@ -77,7 +77,7 @@ std::string CreateJobTemplateRequest::getName()const
 void CreateJobTemplateRequest::setName(const std::string& name)
 {
 	name_ = name;
-	setParameter("Name", name);
+	setCoreParameter("Name", name);
 }
 
 std::string CreateJobTemplateRequest::getRunasUser()const
@@ -88,7 +88,7 @@ std::string CreateJobTemplateRequest::getRunasUser()const
 void CreateJobTemplateRequest::setRunasUser(const std::string& runasUser)
 {
 	runasUser_ = runasUser;
-	setParameter("RunasUser", runasUser);
+	setCoreParameter("RunasUser", runasUser);
 }
 
 std::string CreateJobTemplateRequest::getStdoutRedirectPath()const
@@ -99,7 +99,7 @@ std::string CreateJobTemplateRequest::getStdoutRedirectPath()const
 void CreateJobTemplateRequest::setStdoutRedirectPath(const std::string& stdoutRedirectPath)
 {
 	stdoutRedirectPath_ = stdoutRedirectPath;
-	setParameter("StdoutRedirectPath", stdoutRedirectPath);
+	setCoreParameter("StdoutRedirectPath", stdoutRedirectPath);
 }
 
 bool CreateJobTemplateRequest::getReRunable()const
@@ -110,7 +110,7 @@ bool CreateJobTemplateRequest::getReRunable()const
 void CreateJobTemplateRequest::setReRunable(bool reRunable)
 {
 	reRunable_ = reRunable;
-	setParameter("ReRunable", std::to_string(reRunable));
+	setCoreParameter("ReRunable", reRunable ? "true" : "false");
 }
 
 int CreateJobTemplateRequest::getPriority()const
@@ -121,7 +121,7 @@ int CreateJobTemplateRequest::getPriority()const
 void CreateJobTemplateRequest::setPriority(int priority)
 {
 	priority_ = priority;
-	setParameter("Priority", std::to_string(priority));
+	setCoreParameter("Priority", std::to_string(priority));
 }
 
 std::string CreateJobTemplateRequest::getCommandLine()const
@@ -132,7 +132,7 @@ std::string CreateJobTemplateRequest::getCommandLine()const
 void CreateJobTemplateRequest::setCommandLine(const std::string& commandLine)
 {
 	commandLine_ = commandLine;
-	setParameter("CommandLine", commandLine);
+	setCoreParameter("CommandLine", commandLine);
 }
 
 std::string CreateJobTemplateRequest::getAccessKeyId()const
@@ -143,6 +143,6 @@ std::string CreateJobTemplateRequest::getAccessKeyId()const
 void CreateJobTemplateRequest::setAccessKeyId(const std::string& accessKeyId)
 {
 	accessKeyId_ = accessKeyId;
-	setParameter("AccessKeyId", accessKeyId);
+	setCoreParameter("AccessKeyId", accessKeyId);
 }
 

ehpc/src/model/DeleteClusterRequest.cc

@@ -33,7 +33,7 @@ std::string DeleteClusterRequest::getReleaseInstance()const
 void DeleteClusterRequest::setReleaseInstance(const std::string& releaseInstance)
 {
 	releaseInstance_ = releaseInstance;
-	setParameter("ReleaseInstance", releaseInstance);
+	setCoreParameter("ReleaseInstance", releaseInstance);
 }
 
 std::string DeleteClusterRequest::getClusterId()const
@@ -44,7 +44,7 @@ std::string DeleteClusterRequest::getClusterId()const
 void DeleteClusterRequest::setClusterId(const std::string& clusterId)
 {
 	clusterId_ = clusterId;
-	setParameter("ClusterId", clusterId);
+	setCoreParameter("ClusterId", clusterId);
 }
 
 std::string DeleteClusterRequest::getAccessKeyId()const
@@ -55,6 +55,6 @@ std::string DeleteClusterRequest::getAccessKeyId()const
 void DeleteClusterRequest::setAccessKeyId(const std::string& accessKeyId)
 {
 	accessKeyId_ = accessKeyId;
-	setParameter("AccessKeyId", accessKeyId);
+	setCoreParameter("AccessKeyId", accessKeyId);
 }
 

ehpc/src/model/DeleteContainerAppsRequest.cc

@@ -37,7 +37,7 @@ void DeleteContainerAppsRequest::setContainerApp(const std::vector<ContainerApp>
 	for(int i = 0; i!= containerApp.size(); i++)	{
 		auto obj = containerApp.at(i);
 		std::string str ="ContainerApp."+ std::to_string(i);
-		setParameter(str + ".Id", obj.id);
+		setCoreParameter(str + ".Id", obj.id);
 	}
 }
 
@@ -49,6 +49,6 @@ std::string DeleteContainerAppsRequest::getAccessKeyId()const
 void DeleteContainerAppsRequest::setAccessKeyId(const std::string& accessKeyId)
 {
 	accessKeyId_ = accessKeyId;
-	setParameter("AccessKeyId", accessKeyId);
+	setCoreParameter("AccessKeyId", accessKeyId);
 }
 

ehpc/src/model/DeleteImageRequest.cc

@@ -33,7 +33,7 @@ std::string DeleteImageRequest::getContainerType()const
 void DeleteImageRequest::setContainerType(const std::string& containerType)
 {
 	containerType_ = containerType;
-	setParameter("ContainerType", containerType);
+	setCoreParameter("ContainerType", containerType);
 }
 
 std::string DeleteImageRequest::getClusterId()const
@@ -44,7 +44,7 @@ std::string DeleteImageRequest::getClusterId()const
 void DeleteImageRequest::setClusterId(const std::string& clusterId)
 {
 	clusterId_ = clusterId;
-	setParameter("ClusterId", clusterId);
+	setCoreParameter("ClusterId", clusterId);
 }
 
 std::string DeleteImageRequest::getRepository()const
@@ -55,7 +55,7 @@ std::string DeleteImageRequest::getRepository()const
 void DeleteImageRequest::setRepository(const std::string& repository)
 {
 	repository_ = repository;
-	setParameter("Repository", repository);
+	setCoreParameter("Repository", repository);
 }
 
 std::string DeleteImageRequest::getImageTag()const
@@ -66,7 +66,7 @@ std::string DeleteImageRequest::getImageTag()const
 void DeleteImageRequest::setImageTag(const std::string& imageTag)
 {
 	imageTag_ = imageTag;
-	setParameter("ImageTag", imageTag);
+	setCoreParameter("ImageTag", imageTag);
 }
 
 std::string DeleteImageRequest::getAccessKeyId()const
@@ -77,6 +77,6 @@ std::string DeleteImageRequest::getAccessKeyId()const
 void DeleteImageRequest::setAccessKeyId(const std::string& accessKeyId)
 {
 	accessKeyId_ = accessKeyId;
-	setParameter("AccessKeyId", accessKeyId);
+	setCoreParameter("AccessKeyId", accessKeyId);
 }
 

ehpc/src/model/DeleteJobTemplatesRequest.cc

@@ -33,7 +33,7 @@ std::string DeleteJobTemplatesRequest::getTemplates()const
 void DeleteJobTemplatesRequest::setTemplates(const std::string& templates)
 {
 	templates_ = templates;
-	setParameter("Templates", templates);
+	setCoreParameter("Templates", templates);
 }
 
 std::string DeleteJobTemplatesRequest::getAccessKeyId()const
@@ -44,6 +44,6 @@ std::string DeleteJobTemplatesRequest::getAccessKeyId()const
 void DeleteJobTemplatesRequest::setAccessKeyId(const std::string& accessKeyId)
 {
 	accessKeyId_ = accessKeyId;
-	setParameter("AccessKeyId", accessKeyId);
+	setCoreParameter("AccessKeyId", accessKeyId);
 }
 

ehpc/src/model/DeleteJobsRequest.cc

@@ -33,7 +33,7 @@ std::string DeleteJobsRequest::getJobs()const
 void DeleteJobsRequest::setJobs(const std::string& jobs)
 {
 	jobs_ = jobs;
-	setParameter("Jobs", jobs);
+	setCoreParameter("Jobs", jobs);
 }
 
 std::string DeleteJobsRequest::getClusterId()const
@@ -44,7 +44,7 @@ std::string DeleteJobsRequest::getClusterId()const
 void DeleteJobsRequest::setClusterId(const std::string& clusterId)
 {
 	clusterId_ = clusterId;
-	setParameter("ClusterId", clusterId);
+	setCoreParameter("ClusterId", clusterId);
 }
 
 std::string DeleteJobsRequest::getAccessKeyId()const
@@ -55,6 +55,6 @@ std::string DeleteJobsRequest::getAccessKeyId()const
 void DeleteJobsRequest::setAccessKeyId(const std::string& accessKeyId)
 {
 	accessKeyId_ = accessKeyId;
-	setParameter("AccessKeyId", accessKeyId);
+	setCoreParameter("AccessKeyId", accessKeyId);
 }
 

ehpc/src/model/DeleteNodesRequest.cc

@@ -33,7 +33,7 @@ bool DeleteNodesRequest::getReleaseInstance()const
 void DeleteNodesRequest::setReleaseInstance(bool releaseInstance)
 {
 	releaseInstance_ = releaseInstance;
-	setParameter("ReleaseInstance", std::to_string(releaseInstance));
+	setCoreParameter("ReleaseInstance", releaseInstance ? "true" : "false");
 }
 
 std::vector<DeleteNodesRequest::Instance> DeleteNodesRequest::getInstance()const
@@ -48,7 +48,7 @@ void DeleteNodesRequest::setInstance(const std::vector<Instance>& instance)
 	for(int i = 0; i!= instance.size(); i++)	{
 		auto obj = instance.at(i);
 		std::string str ="Instance."+ std::to_string(i);
-		setParameter(str + ".Id", obj.id);
+		setCoreParameter(str + ".Id", obj.id);
 	}
 }
 
@@ -60,7 +60,7 @@ std::string DeleteNodesRequest::getClusterId()const
 void DeleteNodesRequest::setClusterId(const std::string& clusterId)
 {
 	clusterId_ = clusterId;
-	setParameter("ClusterId", clusterId);
+	setCoreParameter("ClusterId", clusterId);
 }
 
 std::string DeleteNodesRequest::getAccessKeyId()const
@@ -71,6 +71,6 @@ std::string DeleteNodesRequest::getAccessKeyId()const
 void DeleteNodesRequest::setAccessKeyId(const std::string& accessKeyId)
 {
 	accessKeyId_ = accessKeyId;
-	setParameter("AccessKeyId", accessKeyId);
+	setCoreParameter("AccessKeyId", accessKeyId);
 }
 

ehpc/src/model/DeleteQueueRequest.cc

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

ehpc/src/model/DeleteQueueResult.cc

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

ehpc/src/model/DeleteUsersRequest.cc

@@ -33,7 +33,7 @@ std::string DeleteUsersRequest::getClusterId()const
 void DeleteUsersRequest::setClusterId(const std::string& clusterId)
 {
 	clusterId_ = clusterId;
-	setParameter("ClusterId", clusterId);
+	setCoreParameter("ClusterId", clusterId);
 }
 
 std::vector<DeleteUsersRequest::User> DeleteUsersRequest::getUser()const
@@ -48,7 +48,7 @@ void DeleteUsersRequest::setUser(const std::vector<User>& user)
 	for(int i = 0; i!= user.size(); i++)	{
 		auto obj = user.at(i);
 		std::string str ="User."+ std::to_string(i);
-		setParameter(str + ".Name", obj.name);
+		setCoreParameter(str + ".Name", obj.name);
 	}
 }
 
@@ -60,6 +60,6 @@ std::string DeleteUsersRequest::getAccessKeyId()const
 void DeleteUsersRequest::setAccessKeyId(const std::string& accessKeyId)
 {
 	accessKeyId_ = accessKeyId;
-	setParameter("AccessKeyId", accessKeyId);
+	setCoreParameter("AccessKeyId", accessKeyId);
 }
 

ehpc/src/model/DescribeAutoScaleConfigRequest.cc

@@ -33,7 +33,7 @@ std::string DescribeAutoScaleConfigRequest::getClusterId()const
 void DescribeAutoScaleConfigRequest::setClusterId(const std::string& clusterId)
 {
 	clusterId_ = clusterId;
-	setParameter("ClusterId", clusterId);
+	setCoreParameter("ClusterId", clusterId);
 }
 
 std::string DescribeAutoScaleConfigRequest::getAccessKeyId()const
@@ -44,6 +44,6 @@ std::string DescribeAutoScaleConfigRequest::getAccessKeyId()const
 void DescribeAutoScaleConfigRequest::setAccessKeyId(const std::string& accessKeyId)
 {
 	accessKeyId_ = accessKeyId;
-	setParameter("AccessKeyId", accessKeyId);
+	setCoreParameter("AccessKeyId", accessKeyId);
 }
 

ehpc/src/model/DescribeClusterRequest.cc

@@ -33,7 +33,7 @@ std::string DescribeClusterRequest::getClusterId()const
 void DescribeClusterRequest::setClusterId(const std::string& clusterId)
 {
 	clusterId_ = clusterId;
-	setParameter("ClusterId", clusterId);
+	setCoreParameter("ClusterId", clusterId);
 }
 
 std::string DescribeClusterRequest::getAccessKeyId()const
@@ -44,6 +44,6 @@ std::string DescribeClusterRequest::getAccessKeyId()const
 void DescribeClusterRequest::setAccessKeyId(const std::string& accessKeyId)
 {
 	accessKeyId_ = accessKeyId;
-	setParameter("AccessKeyId", accessKeyId);
+	setCoreParameter("AccessKeyId", accessKeyId);
 }
 

ehpc/src/model/DescribeContainerAppRequest.cc

@@ -33,7 +33,7 @@ std::string DescribeContainerAppRequest::getContainerId()const
 void DescribeContainerAppRequest::setContainerId(const std::string& containerId)
 {
 	containerId_ = containerId;
-	setParameter("ContainerId", containerId);
+	setCoreParameter("ContainerId", containerId);
 }
 
 std::string DescribeContainerAppRequest::getAccessKeyId()const
@@ -44,6 +44,6 @@ std::string DescribeContainerAppRequest::getAccessKeyId()const
 void DescribeContainerAppRequest::setAccessKeyId(const std::string& accessKeyId)
 {
 	accessKeyId_ = accessKeyId;
-	setParameter("AccessKeyId", accessKeyId);
+	setCoreParameter("AccessKeyId", accessKeyId);
 }
 

ehpc/src/model/DescribeImageGatewayConfigRequest.cc

@@ -33,7 +33,7 @@ std::string DescribeImageGatewayConfigRequest::getClusterId()const
 void DescribeImageGatewayConfigRequest::setClusterId(const std::string& clusterId)
 {
 	clusterId_ = clusterId;
-	setParameter("ClusterId", clusterId);
+	setCoreParameter("ClusterId", clusterId);
 }
 
 std::string DescribeImageGatewayConfigRequest::getAccessKeyId()const
@@ -44,6 +44,6 @@ std::string DescribeImageGatewayConfigRequest::getAccessKeyId()const
 void DescribeImageGatewayConfigRequest::setAccessKeyId(const std::string& accessKeyId)
 {
 	accessKeyId_ = accessKeyId;
-	setParameter("AccessKeyId", accessKeyId);
+	setCoreParameter("AccessKeyId", accessKeyId);
 }
 

ehpc/src/model/DescribeImagePriceRequest.cc

@@ -33,7 +33,7 @@ int DescribeImagePriceRequest::getPeriod()const
 void DescribeImagePriceRequest::setPeriod(int period)
 {
 	period_ = period;
-	setParameter("Period", std::to_string(period));
+	setCoreParameter("Period", std::to_string(period));
 }
 
 int DescribeImagePriceRequest::getAmount()const
@@ -44,7 +44,7 @@ int DescribeImagePriceRequest::getAmount()const
 void DescribeImagePriceRequest::setAmount(int amount)
 {
 	amount_ = amount;
-	setParameter("Amount", std::to_string(amount));
+	setCoreParameter("Amount", std::to_string(amount));
 }
 
 std::string DescribeImagePriceRequest::getImageId()const
@@ -55,7 +55,7 @@ std::string DescribeImagePriceRequest::getImageId()const
 void DescribeImagePriceRequest::setImageId(const std::string& imageId)
 {
 	imageId_ = imageId;
-	setParameter("ImageId", imageId);
+	setCoreParameter("ImageId", imageId);
 }
 
 std::string DescribeImagePriceRequest::getPriceUnit()const
@@ -66,7 +66,7 @@ std::string DescribeImagePriceRequest::getPriceUnit()const
 void DescribeImagePriceRequest::setPriceUnit(const std::string& priceUnit)
 {
 	priceUnit_ = priceUnit;
-	setParameter("PriceUnit", priceUnit);
+	setCoreParameter("PriceUnit", priceUnit);
 }
 
 std::string DescribeImagePriceRequest::getSkuCode()const
@@ -77,7 +77,7 @@ std::string DescribeImagePriceRequest::getSkuCode()const
 void DescribeImagePriceRequest::setSkuCode(const std::string& skuCode)
 {
 	skuCode_ = skuCode;
-	setParameter("SkuCode", skuCode);
+	setCoreParameter("SkuCode", skuCode);
 }
 
 std::string DescribeImagePriceRequest::getAccessKeyId()const
@@ -88,7 +88,7 @@ std::string DescribeImagePriceRequest::getAccessKeyId()const
 void DescribeImagePriceRequest::setAccessKeyId(const std::string& accessKeyId)
 {
 	accessKeyId_ = accessKeyId;
-	setParameter("AccessKeyId", accessKeyId);
+	setCoreParameter("AccessKeyId", accessKeyId);
 }
 
 std::string DescribeImagePriceRequest::getOrderType()const
@@ -99,6 +99,6 @@ std::string DescribeImagePriceRequest::getOrderType()const
 void DescribeImagePriceRequest::setOrderType(const std::string& orderType)
 {
 	orderType_ = orderType;
-	setParameter("OrderType", orderType);
+	setCoreParameter("OrderType", orderType);
 }
 

ehpc/src/model/DescribeImageRequest.cc

@@ -33,7 +33,7 @@ std::string DescribeImageRequest::getContainerType()const
 void DescribeImageRequest::setContainerType(const std::string& containerType)
 {
 	containerType_ = containerType;
-	setParameter("ContainerType", containerType);
+	setCoreParameter("ContainerType", containerType);
 }
 
 std::string DescribeImageRequest::getClusterId()const
@@ -44,7 +44,7 @@ std::string DescribeImageRequest::getClusterId()const
 void DescribeImageRequest::setClusterId(const std::string& clusterId)
 {
 	clusterId_ = clusterId;
-	setParameter("ClusterId", clusterId);
+	setCoreParameter("ClusterId", clusterId);
 }
 
 std::string DescribeImageRequest::getRepository()const
@@ -55,7 +55,7 @@ std::string DescribeImageRequest::getRepository()const
 void DescribeImageRequest::setRepository(const std::string& repository)
 {
 	repository_ = repository;
-	setParameter("Repository", repository);
+	setCoreParameter("Repository", repository);
 }
 
 std::string DescribeImageRequest::getImageTag()const
@@ -66,7 +66,7 @@ std::string DescribeImageRequest::getImageTag()const
 void DescribeImageRequest::setImageTag(const std::string& imageTag)
 {
 	imageTag_ = imageTag;
-	setParameter("ImageTag", imageTag);
+	setCoreParameter("ImageTag", imageTag);
 }
 
 std::string DescribeImageRequest::getAccessKeyId()const
@@ -77,6 +77,6 @@ std::string DescribeImageRequest::getAccessKeyId()const
 void DescribeImageRequest::setAccessKeyId(const std::string& accessKeyId)
 {
 	accessKeyId_ = accessKeyId;
-	setParameter("AccessKeyId", accessKeyId);
+	setCoreParameter("AccessKeyId", accessKeyId);
 }
 

ehpc/src/model/DescribeJobRequest.cc

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

ehpc/src/model/DescribeJobResult.cc

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

ehpc/src/model/DescribePriceRequest.cc

@@ -33,7 +33,7 @@ std::string DescribePriceRequest::getPriceUnit()const
 void DescribePriceRequest::setPriceUnit(const std::string& priceUnit)
 {
 	priceUnit_ = priceUnit;
-	setParameter("PriceUnit", priceUnit);
+	setCoreParameter("PriceUnit", priceUnit);
 }
 
 std::vector<DescribePriceRequest::Commodities> DescribePriceRequest::getCommodities()const
@@ -48,13 +48,13 @@ void DescribePriceRequest::setCommodities(const std::vector<Commodities>& commod
 	for(int i = 0; i!= commodities.size(); i++)	{
 		auto obj = commodities.at(i);
 		std::string str ="Commodities."+ std::to_string(i);
-		setParameter(str + ".Amount", std::to_string(obj.amount));
-		setParameter(str + ".Period", std::to_string(obj.period));
-		setParameter(str + ".NodeType", obj.nodeType);
-		setParameter(str + ".SystemDiskCategory", obj.systemDiskCategory);
-		setParameter(str + ".SystemDiskSize", std::to_string(obj.systemDiskSize));
-		setParameter(str + ".InstanceType", obj.instanceType);
-		setParameter(str + ".NetworkType", obj.networkType);
+		setCoreParameter(str + ".Amount", std::to_string(obj.amount));
+		setCoreParameter(str + ".Period", std::to_string(obj.period));
+		setCoreParameter(str + ".NodeType", obj.nodeType);
+		setCoreParameter(str + ".SystemDiskCategory", obj.systemDiskCategory);
+		setCoreParameter(str + ".SystemDiskSize", std::to_string(obj.systemDiskSize));
+		setCoreParameter(str + ".InstanceType", obj.instanceType);
+		setCoreParameter(str + ".NetworkType", obj.networkType);
 	}
 }
 
@@ -66,7 +66,7 @@ std::string DescribePriceRequest::getChargeType()const
 void DescribePriceRequest::setChargeType(const std::string& chargeType)
 {
 	chargeType_ = chargeType;
-	setParameter("ChargeType", chargeType);
+	setCoreParameter("ChargeType", chargeType);
 }
 
 std::string DescribePriceRequest::getAccessKeyId()const
@@ -77,7 +77,7 @@ std::string DescribePriceRequest::getAccessKeyId()const
 void DescribePriceRequest::setAccessKeyId(const std::string& accessKeyId)
 {
 	accessKeyId_ = accessKeyId;
-	setParameter("AccessKeyId", accessKeyId);
+	setCoreParameter("AccessKeyId", accessKeyId);
 }
 
 std::string DescribePriceRequest::getOrderType()const
@@ -88,6 +88,6 @@ std::string DescribePriceRequest::getOrderType()const
 void DescribePriceRequest::setOrderType(const std::string& orderType)
 {
 	orderType_ = orderType;
-	setParameter("OrderType", orderType);
+	setCoreParameter("OrderType", orderType);
 }
 

ehpc/src/model/EditJobTemplateRequest.cc

@@ -33,7 +33,7 @@ std::string EditJobTemplateRequest::getStderrRedirectPath()const
 void EditJobTemplateRequest::setStderrRedirectPath(const std::string& stderrRedirectPath)
 {
 	stderrRedirectPath_ = stderrRedirectPath;
-	setParameter("StderrRedirectPath", stderrRedirectPath);
+	setCoreParameter("StderrRedirectPath", stderrRedirectPath);
 }
 
 std::string EditJobTemplateRequest::getVariables()const
@@ -44,7 +44,7 @@ std::string EditJobTemplateRequest::getVariables()const
 void EditJobTemplateRequest::setVariables(const std::string& variables)
 {
 	variables_ = variables;
-	setParameter("Variables", variables);
+	setCoreParameter("Variables", variables);
 }
 
 std::string EditJobTemplateRequest::getRunasUser()const
@@ -55,7 +55,7 @@ std::string EditJobTemplateRequest::getRunasUser()const
 void EditJobTemplateRequest::setRunasUser(const std::string& runasUser)
 {
 	runasUser_ = runasUser;
-	setParameter("RunasUser", runasUser);
+	setCoreParameter("RunasUser", runasUser);
 }
 
 bool EditJobTemplateRequest::getReRunable()const
@@ -66,7 +66,7 @@ bool EditJobTemplateRequest::getReRunable()const
 void EditJobTemplateRequest::setReRunable(bool reRunable)
 {
 	reRunable_ = reRunable;
-	setParameter("ReRunable", std::to_string(reRunable));
+	setCoreParameter("ReRunable", reRunable ? "true" : "false");
 }
 
 std::string EditJobTemplateRequest::getTemplateId()const
@@ -77,7 +77,7 @@ std::string EditJobTemplateRequest::getTemplateId()const
 void EditJobTemplateRequest::setTemplateId(const std::string& templateId)
 {
 	templateId_ = templateId;
-	setParameter("TemplateId", templateId);
+	setCoreParameter("TemplateId", templateId);
 }
 
 int EditJobTemplateRequest::getPriority()const
@@ -88,7 +88,7 @@ int EditJobTemplateRequest::getPriority()const
 void EditJobTemplateRequest::setPriority(int priority)
 {
 	priority_ = priority;
-	setParameter("Priority", std::to_string(priority));
+	setCoreParameter("Priority", std::to_string(priority));
 }
 
 std::string EditJobTemplateRequest::getCommandLine()const
@@ -99,7 +99,7 @@ std::string EditJobTemplateRequest::getCommandLine()const
 void EditJobTemplateRequest::setCommandLine(const std::string& commandLine)
 {
 	commandLine_ = commandLine;
-	setParameter("CommandLine", commandLine);
+	setCoreParameter("CommandLine", commandLine);
 }
 
 std::string EditJobTemplateRequest::getAccessKeyId()const
@@ -110,7 +110,7 @@ std::string EditJobTemplateRequest::getAccessKeyId()const
 void EditJobTemplateRequest::setAccessKeyId(const std::string& accessKeyId)
 {
 	accessKeyId_ = accessKeyId;
-	setParameter("AccessKeyId", accessKeyId);
+	setCoreParameter("AccessKeyId", accessKeyId);
 }
 
 std::string EditJobTemplateRequest::getArrayRequest()const
@@ -121,7 +121,7 @@ std::string EditJobTemplateRequest::getArrayRequest()const
 void EditJobTemplateRequest::setArrayRequest(const std::string& arrayRequest)
 {
 	arrayRequest_ = arrayRequest;
-	setParameter("ArrayRequest", arrayRequest);
+	setCoreParameter("ArrayRequest", arrayRequest);
 }
 
 std::string EditJobTemplateRequest::getPackagePath()const
@@ -132,7 +132,7 @@ std::string EditJobTemplateRequest::getPackagePath()const
 void EditJobTemplateRequest::setPackagePath(const std::string& packagePath)
 {
 	packagePath_ = packagePath;
-	setParameter("PackagePath", packagePath);
+	setCoreParameter("PackagePath", packagePath);
 }
 
 std::string EditJobTemplateRequest::getName()const
@@ -143,7 +143,7 @@ std::string EditJobTemplateRequest::getName()const
 void EditJobTemplateRequest::setName(const std::string& name)
 {
 	name_ = name;
-	setParameter("Name", name);
+	setCoreParameter("Name", name);
 }
 
 std::string EditJobTemplateRequest::getStdoutRedirectPath()const
@@ -154,6 +154,6 @@ std::string EditJobTemplateRequest::getStdoutRedirectPath()const
 void EditJobTemplateRequest::setStdoutRedirectPath(const std::string& stdoutRedirectPath)
 {
 	stdoutRedirectPath_ = stdoutRedirectPath;
-	setParameter("StdoutRedirectPath", stdoutRedirectPath);
+	setCoreParameter("StdoutRedirectPath", stdoutRedirectPath);
 }
 

ehpc/src/model/GetAccountingReportRequest.cc

@@ -0,0 +1,82 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/ehpc/model/GetAccountingReportRequest.h>
+
+using AlibabaCloud::EHPC::Model::GetAccountingReportRequest;
+
+GetAccountingReportRequest::GetAccountingReportRequest() :
+	RpcServiceRequest("ehpc", "2018-04-12", "GetAccountingReport")
+{}
+
+GetAccountingReportRequest::~GetAccountingReportRequest()
+{}
+
+std::string GetAccountingReportRequest::getReportType()const
+{
+	return reportType_;
+}
+
+void GetAccountingReportRequest::setReportType(const std::string& reportType)
+{
+	reportType_ = reportType;
+	setCoreParameter("ReportType", reportType);
+}
+
+int GetAccountingReportRequest::getEndTime()const
+{
+	return endTime_;
+}
+
+void GetAccountingReportRequest::setEndTime(int endTime)
+{
+	endTime_ = endTime;
+	setCoreParameter("EndTime", std::to_string(endTime));
+}
+
+std::string GetAccountingReportRequest::getClusterId()const
+{
+	return clusterId_;
+}
+
+void GetAccountingReportRequest::setClusterId(const std::string& clusterId)
+{
+	clusterId_ = clusterId;
+	setCoreParameter("ClusterId", clusterId);
+}
+
+int GetAccountingReportRequest::getStartTime()const
+{
+	return startTime_;
+}
+
+void GetAccountingReportRequest::setStartTime(int startTime)
+{
+	startTime_ = startTime;
+	setCoreParameter("StartTime", std::to_string(startTime));
+}
+
+std::string GetAccountingReportRequest::getAccessKeyId()const
+{
+	return accessKeyId_;
+}
+
+void GetAccountingReportRequest::setAccessKeyId(const std::string& accessKeyId)
+{
+	accessKeyId_ = accessKeyId;
+	setCoreParameter("AccessKeyId", accessKeyId);
+}
+

ehpc/src/model/GetAccountingReportResult.cc

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

ehpc/src/model/GetAutoScaleConfigRequest.cc

@@ -33,7 +33,7 @@ std::string GetAutoScaleConfigRequest::getClusterId()const
 void GetAutoScaleConfigRequest::setClusterId(const std::string& clusterId)
 {
 	clusterId_ = clusterId;
-	setParameter("ClusterId", clusterId);
+	setCoreParameter("ClusterId", clusterId);
 }
 
 std::string GetAutoScaleConfigRequest::getAccessKeyId()const
@@ -44,6 +44,6 @@ std::string GetAutoScaleConfigRequest::getAccessKeyId()const
 void GetAutoScaleConfigRequest::setAccessKeyId(const std::string& accessKeyId)
 {
 	accessKeyId_ = accessKeyId;
-	setParameter("AccessKeyId", accessKeyId);
+	setCoreParameter("AccessKeyId", accessKeyId);
 }
 

ehpc/src/model/GetAutoScaleConfigResult.cc

@@ -56,6 +56,18 @@ void GetAutoScaleConfigResult::parse(const std::string &payload)
 			queuesObject.enableAutoGrow = value["EnableAutoGrow"].asString() == "true";
 		if(!value["EnableAutoShrink"].isNull())
 			queuesObject.enableAutoShrink = value["EnableAutoShrink"].asString() == "true";
+		auto allInstanceTypes = value["InstanceTypes"]["InstanceTypeInfo"];
+		for (auto value : allInstanceTypes)
+		{
+			QueueInfo::InstanceTypeInfo instanceTypesObject;
+			if(!value["InstanceType"].isNull())
+				instanceTypesObject.instanceType = value["InstanceType"].asString();
+			if(!value["SpotStrategy"].isNull())
+				instanceTypesObject.spotStrategy = value["SpotStrategy"].asString();
+			if(!value["SpotPriceLimit"].isNull())
+				instanceTypesObject.spotPriceLimit = std::stof(value["SpotPriceLimit"].asString());
+			queuesObject.instanceTypes.push_back(instanceTypesObject);
+		}
 		queues_.push_back(queuesObject);
 	}
 	if(!value["Uid"].isNull())

ehpc/src/model/GetCloudMetricLogsRequest.cc

@@ -33,7 +33,7 @@ std::string GetCloudMetricLogsRequest::getAggregationType()const
 void GetCloudMetricLogsRequest::setAggregationType(const std::string& aggregationType)
 {
 	aggregationType_ = aggregationType;
-	setParameter("AggregationType", aggregationType);
+	setCoreParameter("AggregationType", aggregationType);
 }
 
 std::string GetCloudMetricLogsRequest::getFilter()const
@@ -44,7 +44,7 @@ std::string GetCloudMetricLogsRequest::getFilter()const
 void GetCloudMetricLogsRequest::setFilter(const std::string& filter)
 {
 	filter_ = filter;
-	setParameter("Filter", filter);
+	setCoreParameter("Filter", filter);
 }
 
 std::string GetCloudMetricLogsRequest::getMetricCategories()const
@@ -55,7 +55,7 @@ std::string GetCloudMetricLogsRequest::getMetricCategories()const
 void GetCloudMetricLogsRequest::setMetricCategories(const std::string& metricCategories)
 {
 	metricCategories_ = metricCategories;
-	setParameter("MetricCategories", metricCategories);
+	setCoreParameter("MetricCategories", metricCategories);
 }
 
 std::string GetCloudMetricLogsRequest::getMetricScope()const
@@ -66,7 +66,7 @@ std::string GetCloudMetricLogsRequest::getMetricScope()const
 void GetCloudMetricLogsRequest::setMetricScope(const std::string& metricScope)
 {
 	metricScope_ = metricScope;
-	setParameter("MetricScope", metricScope);
+	setCoreParameter("MetricScope", metricScope);
 }
 
 int GetCloudMetricLogsRequest::getFrom()const
@@ -77,7 +77,7 @@ int GetCloudMetricLogsRequest::getFrom()const
 void GetCloudMetricLogsRequest::setFrom(int from)
 {
 	from_ = from;
-	setParameter("From", std::to_string(from));
+	setCoreParameter("From", std::to_string(from));
 }
 
 std::string GetCloudMetricLogsRequest::getClusterId()const
@@ -88,7 +88,7 @@ std::string GetCloudMetricLogsRequest::getClusterId()const
 void GetCloudMetricLogsRequest::setClusterId(const std::string& clusterId)
 {
 	clusterId_ = clusterId;
-	setParameter("ClusterId", clusterId);
+	setCoreParameter("ClusterId", clusterId);
 }
 
 int GetCloudMetricLogsRequest::getTo()const
@@ -99,7 +99,7 @@ int GetCloudMetricLogsRequest::getTo()const
 void GetCloudMetricLogsRequest::setTo(int to)
 {
 	to_ = to;
-	setParameter("To", std::to_string(to));
+	setCoreParameter("To", std::to_string(to));
 }
 
 int GetCloudMetricLogsRequest::getAggregationInterval()const
@@ -110,7 +110,7 @@ int GetCloudMetricLogsRequest::getAggregationInterval()const
 void GetCloudMetricLogsRequest::setAggregationInterval(int aggregationInterval)
 {
 	aggregationInterval_ = aggregationInterval;
-	setParameter("AggregationInterval", std::to_string(aggregationInterval));
+	setCoreParameter("AggregationInterval", std::to_string(aggregationInterval));
 }
 
 bool GetCloudMetricLogsRequest::getReverse()const
@@ -121,7 +121,7 @@ bool GetCloudMetricLogsRequest::getReverse()const
 void GetCloudMetricLogsRequest::setReverse(bool reverse)
 {
 	reverse_ = reverse;
-	setParameter("Reverse", std::to_string(reverse));
+	setCoreParameter("Reverse", reverse ? "true" : "false");
 }
 
 std::string GetCloudMetricLogsRequest::getAccessKeyId()const
@@ -132,6 +132,6 @@ std::string GetCloudMetricLogsRequest::getAccessKeyId()const
 void GetCloudMetricLogsRequest::setAccessKeyId(const std::string& accessKeyId)
 {
 	accessKeyId_ = accessKeyId;
-	setParameter("AccessKeyId", accessKeyId);
+	setCoreParameter("AccessKeyId", accessKeyId);
 }
 

ehpc/src/model/GetCloudMetricProfilingRequest.cc

@@ -33,7 +33,7 @@ std::string GetCloudMetricProfilingRequest::getRegionId()const
 void GetCloudMetricProfilingRequest::setRegionId(const std::string& regionId)
 {
 	regionId_ = regionId;
-	setParameter("RegionId", regionId);
+	setCoreParameter("RegionId", regionId);
 }
 
 std::string GetCloudMetricProfilingRequest::getProfilingId()const
@@ -44,7 +44,7 @@ std::string GetCloudMetricProfilingRequest::getProfilingId()const
 void GetCloudMetricProfilingRequest::setProfilingId(const std::string& profilingId)
 {
 	profilingId_ = profilingId;
-	setParameter("ProfilingId", profilingId);
+	setCoreParameter("ProfilingId", profilingId);
 }
 
 std::string GetCloudMetricProfilingRequest::getClusterId()const
@@ -55,7 +55,7 @@ std::string GetCloudMetricProfilingRequest::getClusterId()const
 void GetCloudMetricProfilingRequest::setClusterId(const std::string& clusterId)
 {
 	clusterId_ = clusterId;
-	setParameter("ClusterId", clusterId);
+	setCoreParameter("ClusterId", clusterId);
 }
 
 std::string GetCloudMetricProfilingRequest::getAccessKeyId()const
@@ -66,6 +66,6 @@ std::string GetCloudMetricProfilingRequest::getAccessKeyId()const
 void GetCloudMetricProfilingRequest::setAccessKeyId(const std::string& accessKeyId)
 {
 	accessKeyId_ = accessKeyId;
-	setParameter("AccessKeyId", accessKeyId);
+	setCoreParameter("AccessKeyId", accessKeyId);
 }
 

ehpc/src/model/GetClusterVolumesRequest.cc

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

ehpc/src/model/GetClusterVolumesResult.cc

@@ -0,0 +1,89 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/ehpc/model/GetClusterVolumesResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::EHPC;
+using namespace AlibabaCloud::EHPC::Model;
+
+GetClusterVolumesResult::GetClusterVolumesResult() :
+	ServiceResult()
+{}
+
+GetClusterVolumesResult::GetClusterVolumesResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+GetClusterVolumesResult::~GetClusterVolumesResult()
+{}
+
+void GetClusterVolumesResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+
+	setRequestId(value["RequestId"].asString());
+	auto allVolumes = value["Volumes"]["VolumeInfo"];
+	for (auto value : allVolumes)
+	{
+		VolumeInfo volumesObject;
+		if(!value["VolumeId"].isNull())
+			volumesObject.volumeId = value["VolumeId"].asString();
+		if(!value["VolumeType"].isNull())
+			volumesObject.volumeType = value["VolumeType"].asString();
+		if(!value["VolumeProtocol"].isNull())
+			volumesObject.volumeProtocol = value["VolumeProtocol"].asString();
+		if(!value["VolumeMountpoint"].isNull())
+			volumesObject.volumeMountpoint = value["VolumeMountpoint"].asString();
+		if(!value["RemoteDirectory"].isNull())
+			volumesObject.remoteDirectory = value["RemoteDirectory"].asString();
+		if(!value["LocalDirectory"].isNull())
+			volumesObject.localDirectory = value["LocalDirectory"].asString();
+		if(!value["Location"].isNull())
+			volumesObject.location = value["Location"].asString();
+		if(!value["JobQueue"].isNull())
+			volumesObject.jobQueue = value["JobQueue"].asString();
+		if(!value["MustKeep"].isNull())
+			volumesObject.mustKeep = value["MustKeep"].asString() == "true";
+		auto allRoles = value["Roles"]["RoleInfo"];
+		for (auto value : allRoles)
+		{
+			VolumeInfo::RoleInfo rolesObject;
+			if(!value["Name"].isNull())
+				rolesObject.name = value["Name"].asString();
+			volumesObject.roles.push_back(rolesObject);
+		}
+		volumes_.push_back(volumesObject);
+	}
+	if(!value["RegionId"].isNull())
+		regionId_ = value["RegionId"].asString();
+
+}
+
+std::vector<GetClusterVolumesResult::VolumeInfo> GetClusterVolumesResult::getVolumes()const
+{
+	return volumes_;
+}
+
+std::string GetClusterVolumesResult::getRegionId()const
+{
+	return regionId_;
+}
+

ehpc/src/model/GetHybridClusterConfigRequest.cc

@@ -33,7 +33,7 @@ std::string GetHybridClusterConfigRequest::getNode()const
 void GetHybridClusterConfigRequest::setNode(const std::string& node)
 {
 	node_ = node;
-	setParameter("Node", node);
+	setCoreParameter("Node", node);
 }
 
 std::string GetHybridClusterConfigRequest::getClusterId()const
@@ -44,7 +44,7 @@ std::string GetHybridClusterConfigRequest::getClusterId()const
 void GetHybridClusterConfigRequest::setClusterId(const std::string& clusterId)
 {
 	clusterId_ = clusterId;
-	setParameter("ClusterId", clusterId);
+	setCoreParameter("ClusterId", clusterId);
 }
 
 std::string GetHybridClusterConfigRequest::getAccessKeyId()const
@@ -55,6 +55,6 @@ std::string GetHybridClusterConfigRequest::getAccessKeyId()const
 void GetHybridClusterConfigRequest::setAccessKeyId(const std::string& accessKeyId)
 {
 	accessKeyId_ = accessKeyId;
-	setParameter("AccessKeyId", accessKeyId);
+	setCoreParameter("AccessKeyId", accessKeyId);
 }
 

ehpc/src/model/GetVisualServiceStatusRequest.cc

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

ehpc/src/model/GetVisualServiceStatusResult.cc

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

ehpc/src/model/InstallSoftwareRequest.cc

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

ehpc/src/model/InstallSoftwareResult.cc

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

ehpc/src/model/InvokeShellCommandRequest.cc

@@ -37,7 +37,7 @@ void InvokeShellCommandRequest::setInstance(const std::vector<Instance>& instanc
 	for(int i = 0; i!= instance.size(); i++)	{
 		auto obj = instance.at(i);
 		std::string str ="Instance."+ std::to_string(i);
-		setParameter(str + ".Id", obj.id);
+		setCoreParameter(str + ".Id", obj.id);
 	}
 }
 
@@ -49,7 +49,7 @@ std::string InvokeShellCommandRequest::getWorkingDir()const
 void InvokeShellCommandRequest::setWorkingDir(const std::string& workingDir)
 {
 	workingDir_ = workingDir;
-	setParameter("WorkingDir", workingDir);
+	setCoreParameter("WorkingDir", workingDir);
 }
 
 std::string InvokeShellCommandRequest::getClusterId()const
@@ -60,7 +60,7 @@ std::string InvokeShellCommandRequest::getClusterId()const
 void InvokeShellCommandRequest::setClusterId(const std::string& clusterId)
 {
 	clusterId_ = clusterId;
-	setParameter("ClusterId", clusterId);
+	setCoreParameter("ClusterId", clusterId);
 }
 
 std::string InvokeShellCommandRequest::getCommand()const
@@ -71,7 +71,7 @@ std::string InvokeShellCommandRequest::getCommand()const
 void InvokeShellCommandRequest::setCommand(const std::string& command)
 {
 	command_ = command;
-	setParameter("Command", command);
+	setCoreParameter("Command", command);
 }
 
 int InvokeShellCommandRequest::getTimeout()const
@@ -82,7 +82,7 @@ int InvokeShellCommandRequest::getTimeout()const
 void InvokeShellCommandRequest::setTimeout(int timeout)
 {
 	timeout_ = timeout;
-	setParameter("Timeout", std::to_string(timeout));
+	setCoreParameter("Timeout", std::to_string(timeout));
 }
 
 std::string InvokeShellCommandRequest::getAccessKeyId()const
@@ -93,6 +93,6 @@ std::string InvokeShellCommandRequest::getAccessKeyId()const
 void InvokeShellCommandRequest::setAccessKeyId(const std::string& accessKeyId)
 {
 	accessKeyId_ = accessKeyId;
-	setParameter("AccessKeyId", accessKeyId);
+	setCoreParameter("AccessKeyId", accessKeyId);
 }
 

ehpc/src/model/ListAvailableEcsTypesRequest.cc

@@ -33,7 +33,7 @@ std::string ListAvailableEcsTypesRequest::getSpotStrategy()const
 void ListAvailableEcsTypesRequest::setSpotStrategy(const std::string& spotStrategy)
 {
 	spotStrategy_ = spotStrategy;
-	setParameter("SpotStrategy", spotStrategy);
+	setCoreParameter("SpotStrategy", spotStrategy);
 }
 
 std::string ListAvailableEcsTypesRequest::getZoneId()const
@@ -44,7 +44,7 @@ std::string ListAvailableEcsTypesRequest::getZoneId()const
 void ListAvailableEcsTypesRequest::setZoneId(const std::string& zoneId)
 {
 	zoneId_ = zoneId;
-	setParameter("ZoneId", zoneId);
+	setCoreParameter("ZoneId", zoneId);
 }
 
 std::string ListAvailableEcsTypesRequest::getInstanceChargeType()const
@@ -55,7 +55,7 @@ std::string ListAvailableEcsTypesRequest::getInstanceChargeType()const
 void ListAvailableEcsTypesRequest::setInstanceChargeType(const std::string& instanceChargeType)
 {
 	instanceChargeType_ = instanceChargeType;
-	setParameter("InstanceChargeType", instanceChargeType);
+	setCoreParameter("InstanceChargeType", instanceChargeType);
 }
 
 std::string ListAvailableEcsTypesRequest::getAccessKeyId()const
@@ -66,6 +66,6 @@ std::string ListAvailableEcsTypesRequest::getAccessKeyId()const
 void ListAvailableEcsTypesRequest::setAccessKeyId(const std::string& accessKeyId)
 {
 	accessKeyId_ = accessKeyId;
-	setParameter("AccessKeyId", accessKeyId);
+	setCoreParameter("AccessKeyId", accessKeyId);
 }
 

ehpc/src/model/ListAvailableFileSystemTypesRequest.cc

@@ -0,0 +1,38 @@
+/*
+ * 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")
+{}
+
+ListAvailableFileSystemTypesRequest::~ListAvailableFileSystemTypesRequest()
+{}
+
+std::string ListAvailableFileSystemTypesRequest::getAccessKeyId()const
+{
+	return accessKeyId_;
+}
+
+void ListAvailableFileSystemTypesRequest::setAccessKeyId(const std::string& accessKeyId)
+{
+	accessKeyId_ = accessKeyId;
+	setCoreParameter("AccessKeyId", accessKeyId);
+}
+

ehpc/src/model/ListAvailableFileSystemTypesResult.cc

@@ -0,0 +1,65 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/ehpc/model/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 allFileSystemTypeList = value["FileSystemTypeList"]["FileSystemTypes"];
+	for (auto value : allFileSystemTypeList)
+	{
+		FileSystemTypes fileSystemTypeListObject;
+		if(!value["FileSystemType"].isNull())
+			fileSystemTypeListObject.fileSystemType = value["FileSystemType"].asString();
+		if(!value["Available"].isNull())
+			fileSystemTypeListObject.available = value["Available"].asString() == "true";
+		if(!value["ProtocolType"].isNull())
+			fileSystemTypeListObject.protocolType = value["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/ListCloudMetricProfilingsRequest.cc

@@ -33,7 +33,7 @@ std::string ListCloudMetricProfilingsRequest::getRegionId()const
 void ListCloudMetricProfilingsRequest::setRegionId(const std::string& regionId)
 {
 	regionId_ = regionId;
-	setParameter("RegionId", regionId);
+	setCoreParameter("RegionId", regionId);
 }
 
 int ListCloudMetricProfilingsRequest::getPageSize()const
@@ -44,7 +44,7 @@ int ListCloudMetricProfilingsRequest::getPageSize()const
 void ListCloudMetricProfilingsRequest::setPageSize(int pageSize)
 {
 	pageSize_ = pageSize;
-	setParameter("PageSize", std::to_string(pageSize));
+	setCoreParameter("PageSize", std::to_string(pageSize));
 }
 
 std::string ListCloudMetricProfilingsRequest::getClusterId()const
@@ -55,7 +55,7 @@ std::string ListCloudMetricProfilingsRequest::getClusterId()const
 void ListCloudMetricProfilingsRequest::setClusterId(const std::string& clusterId)
 {
 	clusterId_ = clusterId;
-	setParameter("ClusterId", clusterId);
+	setCoreParameter("ClusterId", clusterId);
 }
 
 int ListCloudMetricProfilingsRequest::getPageNumber()const
@@ -66,7 +66,7 @@ int ListCloudMetricProfilingsRequest::getPageNumber()const
 void ListCloudMetricProfilingsRequest::setPageNumber(int pageNumber)
 {
 	pageNumber_ = pageNumber;
-	setParameter("PageNumber", std::to_string(pageNumber));
+	setCoreParameter("PageNumber", std::to_string(pageNumber));
 }
 
 std::string ListCloudMetricProfilingsRequest::getAccessKeyId()const
@@ -77,6 +77,6 @@ std::string ListCloudMetricProfilingsRequest::getAccessKeyId()const
 void ListCloudMetricProfilingsRequest::setAccessKeyId(const std::string& accessKeyId)
 {
 	accessKeyId_ = accessKeyId;
-	setParameter("AccessKeyId", accessKeyId);
+	setCoreParameter("AccessKeyId", accessKeyId);
 }