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

Signed-off-by: yixiong.jxy <yixiong.jxy@alibaba-inc.com>

CHANGELOG

@@ -1,3 +1,6 @@
+2018-08-03 Version: 1.21.0
+1, Add new API AddLocalNodes, for adding local machine to a hybrid cluster
+
 2018-08-01 Version: 1.20.5
 1, Add new API GetConversationDetailByContactId
 

VERSION

@@ -1 +1 @@
-1.20.5
+1.21.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/DeleteImageRequest.h
+	include/alibabacloud/ehpc/model/DeleteImageResult.h
 	include/alibabacloud/ehpc/model/DeleteUsersRequest.h
 	include/alibabacloud/ehpc/model/DeleteUsersResult.h
 	include/alibabacloud/ehpc/model/DescribeClusterRequest.h
@@ -69,12 +71,16 @@ set(ehpc_public_header_model
 	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/DeleteJobTemplatesRequest.h
 	include/alibabacloud/ehpc/model/DeleteJobTemplatesResult.h
 	include/alibabacloud/ehpc/model/StopClusterRequest.h
 	include/alibabacloud/ehpc/model/StopClusterResult.h
 	include/alibabacloud/ehpc/model/ListNodesNoPagingRequest.h
 	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
@@ -93,6 +99,8 @@ set(ehpc_public_header_model
 	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/UpgradeClientRequest.h
@@ -107,6 +115,8 @@ set(ehpc_public_header_model
 	include/alibabacloud/ehpc/model/DeleteContainerAppsResult.h
 	include/alibabacloud/ehpc/model/ListInvocationStatusRequest.h
 	include/alibabacloud/ehpc/model/ListInvocationStatusResult.h
+	include/alibabacloud/ehpc/model/ModifyImageGatewayConfigRequest.h
+	include/alibabacloud/ehpc/model/ModifyImageGatewayConfigResult.h
 	include/alibabacloud/ehpc/model/ListContainerAppsRequest.h
 	include/alibabacloud/ehpc/model/ListContainerAppsResult.h
 	include/alibabacloud/ehpc/model/SetJobUserRequest.h
@@ -123,6 +133,8 @@ set(ehpc_public_header_model
 	include/alibabacloud/ehpc/model/RerunJobsResult.h
 	include/alibabacloud/ehpc/model/EditJobTemplateRequest.h
 	include/alibabacloud/ehpc/model/EditJobTemplateResult.h
+	include/alibabacloud/ehpc/model/AddLocalNodesRequest.h
+	include/alibabacloud/ehpc/model/AddLocalNodesResult.h
 	include/alibabacloud/ehpc/model/ListPreferredEcsTypesRequest.h
 	include/alibabacloud/ehpc/model/ListPreferredEcsTypesResult.h
 	include/alibabacloud/ehpc/model/AddContainerAppRequest.h
@@ -134,6 +146,8 @@ set(ehpc_public_header_model
 
 set(ehpc_src 
 	src/EHPCClient.cc
+	src/model/DeleteImageRequest.cc
+	src/model/DeleteImageResult.cc
 	src/model/DeleteUsersRequest.cc
 	src/model/DeleteUsersResult.cc
 	src/model/DescribeClusterRequest.cc
@@ -182,12 +196,16 @@ set(ehpc_src
 	src/model/ListJobTemplatesResult.cc
 	src/model/ModifyClusterAttributesRequest.cc
 	src/model/ModifyClusterAttributesResult.cc
+	src/model/DescribeImageGatewayConfigRequest.cc
+	src/model/DescribeImageGatewayConfigResult.cc
 	src/model/DeleteJobTemplatesRequest.cc
 	src/model/DeleteJobTemplatesResult.cc
 	src/model/StopClusterRequest.cc
 	src/model/StopClusterResult.cc
 	src/model/ListNodesNoPagingRequest.cc
 	src/model/ListNodesNoPagingResult.cc
+	src/model/GetCloudMetricLogsRequest.cc
+	src/model/GetCloudMetricLogsResult.cc
 	src/model/GetHybridClusterConfigRequest.cc
 	src/model/GetHybridClusterConfigResult.cc
 	src/model/CreateJobTemplateRequest.cc
@@ -206,6 +224,8 @@ set(ehpc_src
 	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/UpgradeClientRequest.cc
@@ -220,6 +240,8 @@ set(ehpc_src
 	src/model/DeleteContainerAppsResult.cc
 	src/model/ListInvocationStatusRequest.cc
 	src/model/ListInvocationStatusResult.cc
+	src/model/ModifyImageGatewayConfigRequest.cc
+	src/model/ModifyImageGatewayConfigResult.cc
 	src/model/ListContainerAppsRequest.cc
 	src/model/ListContainerAppsResult.cc
 	src/model/SetJobUserRequest.cc
@@ -236,6 +258,8 @@ set(ehpc_src
 	src/model/RerunJobsResult.cc
 	src/model/EditJobTemplateRequest.cc
 	src/model/EditJobTemplateResult.cc
+	src/model/AddLocalNodesRequest.cc
+	src/model/AddLocalNodesResult.cc
 	src/model/ListPreferredEcsTypesRequest.cc
 	src/model/ListPreferredEcsTypesResult.cc
 	src/model/AddContainerAppRequest.cc

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/DeleteImageRequest.h"
+#include "model/DeleteImageResult.h"
 #include "model/DeleteUsersRequest.h"
 #include "model/DeleteUsersResult.h"
 #include "model/DescribeClusterRequest.h"
@@ -70,12 +72,16 @@
 #include "model/ListJobTemplatesResult.h"
 #include "model/ModifyClusterAttributesRequest.h"
 #include "model/ModifyClusterAttributesResult.h"
+#include "model/DescribeImageGatewayConfigRequest.h"
+#include "model/DescribeImageGatewayConfigResult.h"
 #include "model/DeleteJobTemplatesRequest.h"
 #include "model/DeleteJobTemplatesResult.h"
 #include "model/StopClusterRequest.h"
 #include "model/StopClusterResult.h"
 #include "model/ListNodesNoPagingRequest.h"
 #include "model/ListNodesNoPagingResult.h"
+#include "model/GetCloudMetricLogsRequest.h"
+#include "model/GetCloudMetricLogsResult.h"
 #include "model/GetHybridClusterConfigRequest.h"
 #include "model/GetHybridClusterConfigResult.h"
 #include "model/CreateJobTemplateRequest.h"
@@ -94,6 +100,8 @@
 #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/UpgradeClientRequest.h"
@@ -108,6 +116,8 @@
 #include "model/DeleteContainerAppsResult.h"
 #include "model/ListInvocationStatusRequest.h"
 #include "model/ListInvocationStatusResult.h"
+#include "model/ModifyImageGatewayConfigRequest.h"
+#include "model/ModifyImageGatewayConfigResult.h"
 #include "model/ListContainerAppsRequest.h"
 #include "model/ListContainerAppsResult.h"
 #include "model/SetJobUserRequest.h"
@@ -124,6 +134,8 @@
 #include "model/RerunJobsResult.h"
 #include "model/EditJobTemplateRequest.h"
 #include "model/EditJobTemplateResult.h"
+#include "model/AddLocalNodesRequest.h"
+#include "model/AddLocalNodesResult.h"
 #include "model/ListPreferredEcsTypesRequest.h"
 #include "model/ListPreferredEcsTypesResult.h"
 #include "model/AddContainerAppRequest.h"
@@ -141,6 +153,9 @@ namespace AlibabaCloud
 		class ALIBABACLOUD_EHPC_EXPORT EHPCClient : public RpcServiceClient
 		{
 		public:
+			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;
 			typedef Outcome<Error, Model::DeleteUsersResult> DeleteUsersOutcome;
 			typedef std::future<DeleteUsersOutcome> DeleteUsersOutcomeCallable;
 			typedef std::function<void(const EHPCClient*, const Model::DeleteUsersRequest&, const DeleteUsersOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteUsersAsyncHandler;
@@ -213,6 +228,9 @@ namespace AlibabaCloud
 			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::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;
@@ -222,6 +240,9 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::ListNodesNoPagingResult> ListNodesNoPagingOutcome;
 			typedef std::future<ListNodesNoPagingOutcome> ListNodesNoPagingOutcomeCallable;
 			typedef std::function<void(const EHPCClient*, const Model::ListNodesNoPagingRequest&, const ListNodesNoPagingOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListNodesNoPagingAsyncHandler;
+			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;
@@ -249,6 +270,9 @@ namespace AlibabaCloud
 			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;
@@ -270,6 +294,9 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::ListInvocationStatusResult> ListInvocationStatusOutcome;
 			typedef std::future<ListInvocationStatusOutcome> ListInvocationStatusOutcomeCallable;
 			typedef std::function<void(const EHPCClient*, const Model::ListInvocationStatusRequest&, const ListInvocationStatusOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListInvocationStatusAsyncHandler;
+			typedef Outcome<Error, Model::ModifyImageGatewayConfigResult> ModifyImageGatewayConfigOutcome;
+			typedef std::future<ModifyImageGatewayConfigOutcome> ModifyImageGatewayConfigOutcomeCallable;
+			typedef std::function<void(const EHPCClient*, const Model::ModifyImageGatewayConfigRequest&, const ModifyImageGatewayConfigOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ModifyImageGatewayConfigAsyncHandler;
 			typedef Outcome<Error, Model::ListContainerAppsResult> ListContainerAppsOutcome;
 			typedef std::future<ListContainerAppsOutcome> ListContainerAppsOutcomeCallable;
 			typedef std::function<void(const EHPCClient*, const Model::ListContainerAppsRequest&, const ListContainerAppsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListContainerAppsAsyncHandler;
@@ -294,6 +321,9 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::EditJobTemplateResult> EditJobTemplateOutcome;
 			typedef std::future<EditJobTemplateOutcome> EditJobTemplateOutcomeCallable;
 			typedef std::function<void(const EHPCClient*, const Model::EditJobTemplateRequest&, const EditJobTemplateOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> EditJobTemplateAsyncHandler;
+			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::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;
@@ -311,6 +341,9 @@ namespace AlibabaCloud
 			EHPCClient(const std::shared_ptr<CredentialsProvider> &credentialsProvider, const ClientConfiguration &configuration);
 			EHPCClient(const std::string &accessKeyId, const std::string &accessKeySecret, const ClientConfiguration &configuration);
 			~EHPCClient();
+			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;
 			DeleteUsersOutcome deleteUsers(const Model::DeleteUsersRequest &request)const;
 			void deleteUsersAsync(const Model::DeleteUsersRequest& request, const DeleteUsersAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			DeleteUsersOutcomeCallable deleteUsersCallable(const Model::DeleteUsersRequest& request) const;
@@ -383,6 +416,9 @@ namespace AlibabaCloud
 			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;
 			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;
@@ -392,6 +428,9 @@ namespace AlibabaCloud
 			ListNodesNoPagingOutcome listNodesNoPaging(const Model::ListNodesNoPagingRequest &request)const;
 			void listNodesNoPagingAsync(const Model::ListNodesNoPagingRequest& request, const ListNodesNoPagingAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			ListNodesNoPagingOutcomeCallable listNodesNoPagingCallable(const Model::ListNodesNoPagingRequest& request) const;
+			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;
@@ -419,6 +458,9 @@ namespace AlibabaCloud
 			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;
@@ -440,6 +482,9 @@ namespace AlibabaCloud
 			ListInvocationStatusOutcome listInvocationStatus(const Model::ListInvocationStatusRequest &request)const;
 			void listInvocationStatusAsync(const Model::ListInvocationStatusRequest& request, const ListInvocationStatusAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			ListInvocationStatusOutcomeCallable listInvocationStatusCallable(const Model::ListInvocationStatusRequest& request) const;
+			ModifyImageGatewayConfigOutcome modifyImageGatewayConfig(const Model::ModifyImageGatewayConfigRequest &request)const;
+			void modifyImageGatewayConfigAsync(const Model::ModifyImageGatewayConfigRequest& request, const ModifyImageGatewayConfigAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ModifyImageGatewayConfigOutcomeCallable modifyImageGatewayConfigCallable(const Model::ModifyImageGatewayConfigRequest& request) const;
 			ListContainerAppsOutcome listContainerApps(const Model::ListContainerAppsRequest &request)const;
 			void listContainerAppsAsync(const Model::ListContainerAppsRequest& request, const ListContainerAppsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			ListContainerAppsOutcomeCallable listContainerAppsCallable(const Model::ListContainerAppsRequest& request) const;
@@ -464,6 +509,9 @@ namespace AlibabaCloud
 			EditJobTemplateOutcome editJobTemplate(const Model::EditJobTemplateRequest &request)const;
 			void editJobTemplateAsync(const Model::EditJobTemplateRequest& request, const EditJobTemplateAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			EditJobTemplateOutcomeCallable editJobTemplateCallable(const Model::EditJobTemplateRequest& request) const;
+			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;
 			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;

ehpc/include/alibabacloud/ehpc/model/AddLocalNodesRequest.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_ADDLOCALNODESREQUEST_H_
+#define ALIBABACLOUD_EHPC_MODEL_ADDLOCALNODESREQUEST_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 AddLocalNodesRequest : public RpcServiceRequest
+			{
+
+			public:
+				AddLocalNodesRequest();
+				~AddLocalNodesRequest();
+
+				std::string getNodes()const;
+				void setNodes(const std::string& nodes);
+				std::string getClusterId()const;
+				void setClusterId(const std::string& clusterId);
+				std::string getAccessKeyId()const;
+				void setAccessKeyId(const std::string& accessKeyId);
+
+            private:
+				std::string nodes_;
+				std::string clusterId_;
+				std::string accessKeyId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_EHPC_MODEL_ADDLOCALNODESREQUEST_H_

ehpc/include/alibabacloud/ehpc/model/AddLocalNodesResult.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_ADDLOCALNODESRESULT_H_
+#define ALIBABACLOUD_EHPC_MODEL_ADDLOCALNODESRESULT_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 AddLocalNodesResult : public ServiceResult
+			{
+			public:
+
+
+				AddLocalNodesResult();
+				explicit AddLocalNodesResult(const std::string &payload);
+				~AddLocalNodesResult();
+				std::vector<std::string> getInstanceIds()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::vector<std::string> instanceIds_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_EHPC_MODEL_ADDLOCALNODESRESULT_H_

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

@@ -106,6 +106,8 @@ namespace AlibabaCloud
 				void setAutoRenew(const std::string& autoRenew);
 				std::string getEcsChargeType()const;
 				void setEcsChargeType(const std::string& ecsChargeType);
+				std::string getInputFileUrl()const;
+				void setInputFileUrl(const std::string& inputFileUrl);
 				std::string getVpcId()const;
 				void setVpcId(const std::string& vpcId);
 				bool getHaEnable()const;
@@ -155,6 +157,7 @@ namespace AlibabaCloud
 				std::vector<Application> application_;
 				std::string autoRenew_;
 				std::string ecsChargeType_;
+				std::string inputFileUrl_;
 				std::string vpcId_;
 				bool haEnable_;
 				std::string name_;

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

@@ -39,12 +39,6 @@ namespace AlibabaCloud
 				CreateHybridClusterRequest();
 				~CreateHybridClusterRequest();
 
-				std::string getVolumeProtocol()const;
-				void setVolumeProtocol(const std::string& volumeProtocol);
-				std::string getOsTag()const;
-				void setOsTag(const std::string& osTag);
-				std::string getRemoteDirectory()const;
-				void setRemoteDirectory(const std::string& remoteDirectory);
 				std::string getEhpcVersion()const;
 				void setEhpcVersion(const std::string& ehpcVersion);
 				std::string getSecurityGroupId()const;
@@ -57,14 +51,28 @@ namespace AlibabaCloud
 				void setSecurityGroupName(const std::string& securityGroupName);
 				std::string getEcsOrderComputeInstanceType()const;
 				void setEcsOrderComputeInstanceType(const std::string& ecsOrderComputeInstanceType);
+				std::string getOnPremiseVolumeRemotePath()const;
+				void setOnPremiseVolumeRemotePath(const std::string& onPremiseVolumeRemotePath);
 				std::string getAccessKeyId()const;
 				void setAccessKeyId(const std::string& accessKeyId);
-				std::string getVSwitchId()const;
-				void setVSwitchId(const std::string& vSwitchId);
 				std::string getVolumeType()const;
 				void setVolumeType(const std::string& volumeType);
 				std::string getPassword()const;
 				void setPassword(const std::string& password);
+				std::string getOnPremiseVolumeMountPoint()const;
+				void setOnPremiseVolumeMountPoint(const std::string& onPremiseVolumeMountPoint);
+				std::string getOnPremiseVolumeProtocol()const;
+				void setOnPremiseVolumeProtocol(const std::string& onPremiseVolumeProtocol);
+				std::string getVolumeProtocol()const;
+				void setVolumeProtocol(const std::string& volumeProtocol);
+				std::string getOnPremiseVolumeLocalPath()const;
+				void setOnPremiseVolumeLocalPath(const std::string& onPremiseVolumeLocalPath);
+				std::string getOsTag()const;
+				void setOsTag(const std::string& osTag);
+				std::string getRemoteDirectory()const;
+				void setRemoteDirectory(const std::string& remoteDirectory);
+				std::string getVSwitchId()const;
+				void setVSwitchId(const std::string& vSwitchId);
 				std::string getNodes()const;
 				void setNodes(const std::string& nodes);
 				std::vector<Application> getApplication()const;
@@ -85,19 +93,23 @@ namespace AlibabaCloud
 				void setLocation(const std::string& location);
 
             private:
-				std::string volumeProtocol_;
-				std::string osTag_;
-				std::string remoteDirectory_;
 				std::string ehpcVersion_;
 				std::string securityGroupId_;
 				std::string description_;
 				std::string keyPairName_;
 				std::string securityGroupName_;
 				std::string ecsOrderComputeInstanceType_;
+				std::string onPremiseVolumeRemotePath_;
 				std::string accessKeyId_;
-				std::string vSwitchId_;
 				std::string volumeType_;
 				std::string password_;
+				std::string onPremiseVolumeMountPoint_;
+				std::string onPremiseVolumeProtocol_;
+				std::string volumeProtocol_;
+				std::string onPremiseVolumeLocalPath_;
+				std::string osTag_;
+				std::string remoteDirectory_;
+				std::string vSwitchId_;
 				std::string nodes_;
 				std::vector<Application> application_;
 				std::string domain_;

ehpc/include/alibabacloud/ehpc/model/DeleteImageRequest.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_DELETEIMAGEREQUEST_H_
+#define ALIBABACLOUD_EHPC_MODEL_DELETEIMAGEREQUEST_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 DeleteImageRequest : public RpcServiceRequest
+			{
+
+			public:
+				DeleteImageRequest();
+				~DeleteImageRequest();
+
+				std::string getContainerType()const;
+				void setContainerType(const std::string& containerType);
+				std::string getClusterId()const;
+				void setClusterId(const std::string& clusterId);
+				std::string getRepository()const;
+				void setRepository(const std::string& repository);
+				std::string getImageTag()const;
+				void setImageTag(const std::string& imageTag);
+				std::string getAccessKeyId()const;
+				void setAccessKeyId(const std::string& accessKeyId);
+
+            private:
+				std::string containerType_;
+				std::string clusterId_;
+				std::string repository_;
+				std::string imageTag_;
+				std::string accessKeyId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_EHPC_MODEL_DELETEIMAGEREQUEST_H_

ehpc/include/alibabacloud/ehpc/model/DeleteImageResult.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_DELETEIMAGERESULT_H_
+#define ALIBABACLOUD_EHPC_MODEL_DELETEIMAGERESULT_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 DeleteImageResult : public ServiceResult
+			{
+			public:
+
+
+				DeleteImageResult();
+				explicit DeleteImageResult(const std::string &payload);
+				~DeleteImageResult();
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_EHPC_MODEL_DELETEIMAGERESULT_H_

ehpc/include/alibabacloud/ehpc/model/DescribeClusterResult.h

@@ -61,6 +61,11 @@ namespace AlibabaCloud
 						std::string tag;
 						std::string name;
 					};
+					struct PostInstallScriptInfo
+					{
+						std::string args;
+						std::string url;
+					};
 					std::string volumeProtocol;
 					std::string imageOwnerAlias;
 					std::string description;
@@ -75,6 +80,7 @@ namespace AlibabaCloud
 					std::string remoteDirectory;
 					std::string sccClusterId;
 					std::vector<ApplicationInfo> applications;
+					std::vector<PostInstallScriptInfo> postInstallScripts;
 					std::string createTime;
 					std::string securityGroupId;
 					std::string vSwitchId;

ehpc/include/alibabacloud/ehpc/model/DescribeImageGatewayConfigRequest.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_DESCRIBEIMAGEGATEWAYCONFIGREQUEST_H_
+#define ALIBABACLOUD_EHPC_MODEL_DESCRIBEIMAGEGATEWAYCONFIGREQUEST_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 DescribeImageGatewayConfigRequest : public RpcServiceRequest
+			{
+
+			public:
+				DescribeImageGatewayConfigRequest();
+				~DescribeImageGatewayConfigRequest();
+
+				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_DESCRIBEIMAGEGATEWAYCONFIGREQUEST_H_

ehpc/include/alibabacloud/ehpc/model/DescribeImageGatewayConfigResult.h

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

ehpc/include/alibabacloud/ehpc/model/DescribeImageRequest.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_DESCRIBEIMAGEREQUEST_H_
+#define ALIBABACLOUD_EHPC_MODEL_DESCRIBEIMAGEREQUEST_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 DescribeImageRequest : public RpcServiceRequest
+			{
+
+			public:
+				DescribeImageRequest();
+				~DescribeImageRequest();
+
+				std::string getContainerType()const;
+				void setContainerType(const std::string& containerType);
+				std::string getClusterId()const;
+				void setClusterId(const std::string& clusterId);
+				std::string getRepository()const;
+				void setRepository(const std::string& repository);
+				std::string getImageTag()const;
+				void setImageTag(const std::string& imageTag);
+				std::string getAccessKeyId()const;
+				void setAccessKeyId(const std::string& accessKeyId);
+
+            private:
+				std::string containerType_;
+				std::string clusterId_;
+				std::string repository_;
+				std::string imageTag_;
+				std::string accessKeyId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_EHPC_MODEL_DESCRIBEIMAGEREQUEST_H_

ehpc/include/alibabacloud/ehpc/model/DescribeImageResult.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_DESCRIBEIMAGERESULT_H_
+#define ALIBABACLOUD_EHPC_MODEL_DESCRIBEIMAGERESULT_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 DescribeImageResult : public ServiceResult
+			{
+			public:
+				struct ImageInfo
+				{
+					std::string status;
+					std::string type;
+					std::string repository;
+					std::string imageId;
+					std::string updateDateTime;
+					std::string tag;
+					std::string system;
+				};
+
+
+				DescribeImageResult();
+				explicit DescribeImageResult(const std::string &payload);
+				~DescribeImageResult();
+				ImageInfo getImageInfo()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				ImageInfo imageInfo_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_EHPC_MODEL_DESCRIBEIMAGERESULT_H_

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

@@ -49,7 +49,9 @@ namespace AlibabaCloud
 				std::string getUid()const;
 				int getGrowTimeoutInMinutes()const;
 				int getShrinkIntervalInMinutes()const;
+				std::string getSpotPriceLimit()const;
 				std::string getExcludeNodes()const;
+				std::string getSpotStrategy()const;
 
 			protected:
 				void parse(const std::string &payload);
@@ -66,7 +68,9 @@ namespace AlibabaCloud
 				std::string uid_;
 				int growTimeoutInMinutes_;
 				int shrinkIntervalInMinutes_;
+				std::string spotPriceLimit_;
 				std::string excludeNodes_;
+				std::string spotStrategy_;
 
 			};
 		}

ehpc/include/alibabacloud/ehpc/model/GetCloudMetricLogsRequest.h

@@ -0,0 +1,78 @@
+/*
+ * 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_GETCLOUDMETRICLOGSREQUEST_H_
+#define ALIBABACLOUD_EHPC_MODEL_GETCLOUDMETRICLOGSREQUEST_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 GetCloudMetricLogsRequest : public RpcServiceRequest
+			{
+
+			public:
+				GetCloudMetricLogsRequest();
+				~GetCloudMetricLogsRequest();
+
+				std::string getAggregationType()const;
+				void setAggregationType(const std::string& aggregationType);
+				std::string getFilter()const;
+				void setFilter(const std::string& filter);
+				std::string getMetricCategories()const;
+				void setMetricCategories(const std::string& metricCategories);
+				int getLine()const;
+				void setLine(int line);
+				std::string getMetricScope()const;
+				void setMetricScope(const std::string& metricScope);
+				int getFrom()const;
+				void setFrom(int from);
+				std::string getClusterId()const;
+				void setClusterId(const std::string& clusterId);
+				int getTo()const;
+				void setTo(int to);
+				int getAggregationInterval()const;
+				void setAggregationInterval(int aggregationInterval);
+				bool getReverse()const;
+				void setReverse(bool reverse);
+				std::string getAccessKeyId()const;
+				void setAccessKeyId(const std::string& accessKeyId);
+
+            private:
+				std::string aggregationType_;
+				std::string filter_;
+				std::string metricCategories_;
+				int line_;
+				std::string metricScope_;
+				int from_;
+				std::string clusterId_;
+				int to_;
+				int aggregationInterval_;
+				bool reverse_;
+				std::string accessKeyId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_EHPC_MODEL_GETCLOUDMETRICLOGSREQUEST_H_

ehpc/include/alibabacloud/ehpc/model/GetCloudMetricLogsResult.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_GETCLOUDMETRICLOGSRESULT_H_
+#define ALIBABACLOUD_EHPC_MODEL_GETCLOUDMETRICLOGSRESULT_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 GetCloudMetricLogsResult : public ServiceResult
+			{
+			public:
+				struct MetricLog
+				{
+					std::string instanceId;
+					std::string diskDevice;
+					std::string hostname;
+					std::string networkInterface;
+					int time;
+					std::string metricData;
+				};
+
+
+				GetCloudMetricLogsResult();
+				explicit GetCloudMetricLogsResult(const std::string &payload);
+				~GetCloudMetricLogsResult();
+				std::vector<MetricLog> getMetricLogs()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::vector<MetricLog> metricLogs_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_EHPC_MODEL_GETCLOUDMETRICLOGSRESULT_H_

ehpc/include/alibabacloud/ehpc/model/GetHybridClusterConfigRequest.h

@@ -35,12 +35,15 @@ namespace AlibabaCloud
 				GetHybridClusterConfigRequest();
 				~GetHybridClusterConfigRequest();
 
+				std::string getNode()const;
+				void setNode(const std::string& node);
 				std::string getClusterId()const;
 				void setClusterId(const std::string& clusterId);
 				std::string getAccessKeyId()const;
 				void setAccessKeyId(const std::string& accessKeyId);
 
             private:
+				std::string node_;
 				std::string clusterId_;
 				std::string accessKeyId_;
 

ehpc/include/alibabacloud/ehpc/model/ListJobsResult.h

@@ -43,6 +43,7 @@ namespace AlibabaCloud
 					std::string owner;
 					std::string _stderr;
 					int priority;
+					std::string nodeList;
 					std::string startTime;
 					std::string lastModifyTime;
 					std::string submitTime;

ehpc/include/alibabacloud/ehpc/model/ModifyImageGatewayConfigRequest.h

@@ -0,0 +1,81 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_EHPC_MODEL_MODIFYIMAGEGATEWAYCONFIGREQUEST_H_
+#define ALIBABACLOUD_EHPC_MODEL_MODIFYIMAGEGATEWAYCONFIGREQUEST_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 ModifyImageGatewayConfigRequest : public RpcServiceRequest
+			{
+				struct Repo
+				{
+					std::string location;
+					std::string auth;
+					std::string uRL;
+				};
+
+			public:
+				ModifyImageGatewayConfigRequest();
+				~ModifyImageGatewayConfigRequest();
+
+				std::string getDefaultRepoLocation()const;
+				void setDefaultRepoLocation(const std::string& defaultRepoLocation);
+				std::string getDBPassword()const;
+				void setDBPassword(const std::string& dBPassword);
+				std::vector<Repo> getRepo()const;
+				void setRepo(const std::vector<Repo>& repo);
+				std::string getDBType()const;
+				void setDBType(const std::string& dBType);
+				std::string getDBUsername()const;
+				void setDBUsername(const std::string& dBUsername);
+				std::string getDBServerInfo()const;
+				void setDBServerInfo(const std::string& dBServerInfo);
+				int getPullUpdateTimeout()const;
+				void setPullUpdateTimeout(int pullUpdateTimeout);
+				std::string getClusterId()const;
+				void setClusterId(const std::string& clusterId);
+				std::string getAccessKeyId()const;
+				void setAccessKeyId(const std::string& accessKeyId);
+				std::string getImageExpirationTimeout()const;
+				void setImageExpirationTimeout(const std::string& imageExpirationTimeout);
+
+            private:
+				std::string defaultRepoLocation_;
+				std::string dBPassword_;
+				std::vector<Repo> repo_;
+				std::string dBType_;
+				std::string dBUsername_;
+				std::string dBServerInfo_;
+				int pullUpdateTimeout_;
+				std::string clusterId_;
+				std::string accessKeyId_;
+				std::string imageExpirationTimeout_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_EHPC_MODEL_MODIFYIMAGEGATEWAYCONFIGREQUEST_H_

ehpc/include/alibabacloud/ehpc/model/ModifyImageGatewayConfigResult.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_MODIFYIMAGEGATEWAYCONFIGRESULT_H_
+#define ALIBABACLOUD_EHPC_MODEL_MODIFYIMAGEGATEWAYCONFIGRESULT_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 ModifyImageGatewayConfigResult : public ServiceResult
+			{
+			public:
+
+
+				ModifyImageGatewayConfigResult();
+				explicit ModifyImageGatewayConfigResult(const std::string &payload);
+				~ModifyImageGatewayConfigResult();
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_EHPC_MODEL_MODIFYIMAGEGATEWAYCONFIGRESULT_H_

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

@@ -43,10 +43,14 @@ namespace AlibabaCloud
 				void setClusterId(const std::string& clusterId);
 				bool getEnableAutoGrow()const;
 				void setEnableAutoGrow(bool enableAutoGrow);
+				std::string getSpotPriceLimit()const;
+				void setSpotPriceLimit(const std::string& spotPriceLimit);
 				bool getEnableAutoShrink()const;
 				void setEnableAutoShrink(bool enableAutoShrink);
 				std::string getAccessKeyId()const;
 				void setAccessKeyId(const std::string& accessKeyId);
+				std::string getSpotStrategy()const;
+				void setSpotStrategy(const std::string& spotStrategy);
 				int getMaxNodesInCluster()const;
 				void setMaxNodesInCluster(int maxNodesInCluster);
 				std::string getExcludeNodes()const;
@@ -65,8 +69,10 @@ namespace AlibabaCloud
 				int growTimeoutInMinutes_;
 				std::string clusterId_;
 				bool enableAutoGrow_;
+				std::string spotPriceLimit_;
 				bool enableAutoShrink_;
 				std::string accessKeyId_;
+				std::string spotStrategy_;
 				int maxNodesInCluster_;
 				std::string excludeNodes_;
 				int shrinkIntervalInMinutes_;

ehpc/src/EHPCClient.cc

@@ -51,6 +51,42 @@ EHPCClient::EHPCClient(const std::string & accessKeyId, const std::string & acce
 EHPCClient::~EHPCClient()
 {}
 
+EHPCClient::DeleteImageOutcome EHPCClient::deleteImage(const DeleteImageRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DeleteImageOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DeleteImageOutcome(DeleteImageResult(outcome.result()));
+	else
+		return DeleteImageOutcome(outcome.error());
+}
+
+void EHPCClient::deleteImageAsync(const DeleteImageRequest& request, const DeleteImageAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, deleteImage(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+EHPCClient::DeleteImageOutcomeCallable EHPCClient::deleteImageCallable(const DeleteImageRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DeleteImageOutcome()>>(
+			[this, request]()
+			{
+			return this->deleteImage(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 EHPCClient::DeleteUsersOutcome EHPCClient::deleteUsers(const DeleteUsersRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -915,6 +951,42 @@ EHPCClient::ModifyClusterAttributesOutcomeCallable EHPCClient::modifyClusterAttr
 	return task->get_future();
 }
 
+EHPCClient::DescribeImageGatewayConfigOutcome EHPCClient::describeImageGatewayConfig(const DescribeImageGatewayConfigRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DescribeImageGatewayConfigOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DescribeImageGatewayConfigOutcome(DescribeImageGatewayConfigResult(outcome.result()));
+	else
+		return DescribeImageGatewayConfigOutcome(outcome.error());
+}
+
+void EHPCClient::describeImageGatewayConfigAsync(const DescribeImageGatewayConfigRequest& request, const DescribeImageGatewayConfigAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, describeImageGatewayConfig(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+EHPCClient::DescribeImageGatewayConfigOutcomeCallable EHPCClient::describeImageGatewayConfigCallable(const DescribeImageGatewayConfigRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DescribeImageGatewayConfigOutcome()>>(
+			[this, request]()
+			{
+			return this->describeImageGatewayConfig(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 EHPCClient::DeleteJobTemplatesOutcome EHPCClient::deleteJobTemplates(const DeleteJobTemplatesRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -1023,6 +1095,42 @@ EHPCClient::ListNodesNoPagingOutcomeCallable EHPCClient::listNodesNoPagingCallab
 	return task->get_future();
 }
 
+EHPCClient::GetCloudMetricLogsOutcome EHPCClient::getCloudMetricLogs(const GetCloudMetricLogsRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return GetCloudMetricLogsOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return GetCloudMetricLogsOutcome(GetCloudMetricLogsResult(outcome.result()));
+	else
+		return GetCloudMetricLogsOutcome(outcome.error());
+}
+
+void EHPCClient::getCloudMetricLogsAsync(const GetCloudMetricLogsRequest& request, const GetCloudMetricLogsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, getCloudMetricLogs(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+EHPCClient::GetCloudMetricLogsOutcomeCallable EHPCClient::getCloudMetricLogsCallable(const GetCloudMetricLogsRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<GetCloudMetricLogsOutcome()>>(
+			[this, request]()
+			{
+			return this->getCloudMetricLogs(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 EHPCClient::GetHybridClusterConfigOutcome EHPCClient::getHybridClusterConfig(const GetHybridClusterConfigRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -1347,6 +1455,42 @@ EHPCClient::CreateClusterOutcomeCallable EHPCClient::createClusterCallable(const
 	return task->get_future();
 }
 
+EHPCClient::DescribeImageOutcome EHPCClient::describeImage(const DescribeImageRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DescribeImageOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DescribeImageOutcome(DescribeImageResult(outcome.result()));
+	else
+		return DescribeImageOutcome(outcome.error());
+}
+
+void EHPCClient::describeImageAsync(const DescribeImageRequest& request, const DescribeImageAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, describeImage(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+EHPCClient::DescribeImageOutcomeCallable EHPCClient::describeImageCallable(const DescribeImageRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DescribeImageOutcome()>>(
+			[this, request]()
+			{
+			return this->describeImage(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 EHPCClient::ModifyUserPasswordsOutcome EHPCClient::modifyUserPasswords(const ModifyUserPasswordsRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -1599,6 +1743,42 @@ EHPCClient::ListInvocationStatusOutcomeCallable EHPCClient::listInvocationStatus
 	return task->get_future();
 }
 
+EHPCClient::ModifyImageGatewayConfigOutcome EHPCClient::modifyImageGatewayConfig(const ModifyImageGatewayConfigRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return ModifyImageGatewayConfigOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return ModifyImageGatewayConfigOutcome(ModifyImageGatewayConfigResult(outcome.result()));
+	else
+		return ModifyImageGatewayConfigOutcome(outcome.error());
+}
+
+void EHPCClient::modifyImageGatewayConfigAsync(const ModifyImageGatewayConfigRequest& request, const ModifyImageGatewayConfigAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, modifyImageGatewayConfig(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+EHPCClient::ModifyImageGatewayConfigOutcomeCallable EHPCClient::modifyImageGatewayConfigCallable(const ModifyImageGatewayConfigRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<ModifyImageGatewayConfigOutcome()>>(
+			[this, request]()
+			{
+			return this->modifyImageGatewayConfig(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 EHPCClient::ListContainerAppsOutcome EHPCClient::listContainerApps(const ListContainerAppsRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -1887,6 +2067,42 @@ EHPCClient::EditJobTemplateOutcomeCallable EHPCClient::editJobTemplateCallable(c
 	return task->get_future();
 }
 
+EHPCClient::AddLocalNodesOutcome EHPCClient::addLocalNodes(const AddLocalNodesRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return AddLocalNodesOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return AddLocalNodesOutcome(AddLocalNodesResult(outcome.result()));
+	else
+		return AddLocalNodesOutcome(outcome.error());
+}
+
+void EHPCClient::addLocalNodesAsync(const AddLocalNodesRequest& request, const AddLocalNodesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, addLocalNodes(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+EHPCClient::AddLocalNodesOutcomeCallable EHPCClient::addLocalNodesCallable(const AddLocalNodesRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<AddLocalNodesOutcome()>>(
+			[this, request]()
+			{
+			return this->addLocalNodes(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 EHPCClient::ListPreferredEcsTypesOutcome EHPCClient::listPreferredEcsTypes(const ListPreferredEcsTypesRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();

ehpc/src/model/AddLocalNodesRequest.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/AddLocalNodesRequest.h>
+
+using AlibabaCloud::EHPC::Model::AddLocalNodesRequest;
+
+AddLocalNodesRequest::AddLocalNodesRequest() :
+	RpcServiceRequest("ehpc", "2018-04-12", "AddLocalNodes")
+{}
+
+AddLocalNodesRequest::~AddLocalNodesRequest()
+{}
+
+std::string AddLocalNodesRequest::getNodes()const
+{
+	return nodes_;
+}
+
+void AddLocalNodesRequest::setNodes(const std::string& nodes)
+{
+	nodes_ = nodes;
+	setParameter("Nodes", nodes);
+}
+
+std::string AddLocalNodesRequest::getClusterId()const
+{
+	return clusterId_;
+}
+
+void AddLocalNodesRequest::setClusterId(const std::string& clusterId)
+{
+	clusterId_ = clusterId;
+	setParameter("ClusterId", clusterId);
+}
+
+std::string AddLocalNodesRequest::getAccessKeyId()const
+{
+	return accessKeyId_;
+}
+
+void AddLocalNodesRequest::setAccessKeyId(const std::string& accessKeyId)
+{
+	accessKeyId_ = accessKeyId;
+	setParameter("AccessKeyId", accessKeyId);
+}
+

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

ehpc/src/model/CreateClusterRequest.cc

@@ -377,6 +377,17 @@ void CreateClusterRequest::setEcsChargeType(const std::string& ecsChargeType)
 	setParameter("EcsChargeType", ecsChargeType);
 }
 
+std::string CreateClusterRequest::getInputFileUrl()const
+{
+	return inputFileUrl_;
+}
+
+void CreateClusterRequest::setInputFileUrl(const std::string& inputFileUrl)
+{
+	inputFileUrl_ = inputFileUrl;
+	setParameter("InputFileUrl", inputFileUrl);
+}
+
 std::string CreateClusterRequest::getVpcId()const
 {
 	return vpcId_;

ehpc/src/model/CreateHybridClusterRequest.cc

@@ -25,39 +25,6 @@ CreateHybridClusterRequest::CreateHybridClusterRequest() :
 CreateHybridClusterRequest::~CreateHybridClusterRequest()
 {}
 
-std::string CreateHybridClusterRequest::getVolumeProtocol()const
-{
-	return volumeProtocol_;
-}
-
-void CreateHybridClusterRequest::setVolumeProtocol(const std::string& volumeProtocol)
-{
-	volumeProtocol_ = volumeProtocol;
-	setParameter("VolumeProtocol", volumeProtocol);
-}
-
-std::string CreateHybridClusterRequest::getOsTag()const
-{
-	return osTag_;
-}
-
-void CreateHybridClusterRequest::setOsTag(const std::string& osTag)
-{
-	osTag_ = osTag;
-	setParameter("OsTag", osTag);
-}
-
-std::string CreateHybridClusterRequest::getRemoteDirectory()const
-{
-	return remoteDirectory_;
-}
-
-void CreateHybridClusterRequest::setRemoteDirectory(const std::string& remoteDirectory)
-{
-	remoteDirectory_ = remoteDirectory;
-	setParameter("RemoteDirectory", remoteDirectory);
-}
-
 std::string CreateHybridClusterRequest::getEhpcVersion()const
 {
 	return ehpcVersion_;
@@ -124,26 +91,26 @@ void CreateHybridClusterRequest::setEcsOrderComputeInstanceType(const std::strin
 	setParameter("EcsOrderComputeInstanceType", ecsOrderComputeInstanceType);
 }
 
-std::string CreateHybridClusterRequest::getAccessKeyId()const
+std::string CreateHybridClusterRequest::getOnPremiseVolumeRemotePath()const
 {
-	return accessKeyId_;
+	return onPremiseVolumeRemotePath_;
 }
 
-void CreateHybridClusterRequest::setAccessKeyId(const std::string& accessKeyId)
+void CreateHybridClusterRequest::setOnPremiseVolumeRemotePath(const std::string& onPremiseVolumeRemotePath)
 {
-	accessKeyId_ = accessKeyId;
-	setParameter("AccessKeyId", accessKeyId);
+	onPremiseVolumeRemotePath_ = onPremiseVolumeRemotePath;
+	setParameter("OnPremiseVolumeRemotePath", onPremiseVolumeRemotePath);
 }
 
-std::string CreateHybridClusterRequest::getVSwitchId()const
+std::string CreateHybridClusterRequest::getAccessKeyId()const
 {
-	return vSwitchId_;
+	return accessKeyId_;
 }
 
-void CreateHybridClusterRequest::setVSwitchId(const std::string& vSwitchId)
+void CreateHybridClusterRequest::setAccessKeyId(const std::string& accessKeyId)
 {
-	vSwitchId_ = vSwitchId;
-	setParameter("VSwitchId", vSwitchId);
+	accessKeyId_ = accessKeyId;
+	setParameter("AccessKeyId", accessKeyId);
 }
 
 std::string CreateHybridClusterRequest::getVolumeType()const
@@ -168,6 +135,83 @@ void CreateHybridClusterRequest::setPassword(const std::string& password)
 	setParameter("Password", password);
 }
 
+std::string CreateHybridClusterRequest::getOnPremiseVolumeMountPoint()const
+{
+	return onPremiseVolumeMountPoint_;
+}
+
+void CreateHybridClusterRequest::setOnPremiseVolumeMountPoint(const std::string& onPremiseVolumeMountPoint)
+{
+	onPremiseVolumeMountPoint_ = onPremiseVolumeMountPoint;
+	setParameter("OnPremiseVolumeMountPoint", onPremiseVolumeMountPoint);
+}
+
+std::string CreateHybridClusterRequest::getOnPremiseVolumeProtocol()const
+{
+	return onPremiseVolumeProtocol_;
+}
+
+void CreateHybridClusterRequest::setOnPremiseVolumeProtocol(const std::string& onPremiseVolumeProtocol)
+{
+	onPremiseVolumeProtocol_ = onPremiseVolumeProtocol;
+	setParameter("OnPremiseVolumeProtocol", onPremiseVolumeProtocol);
+}
+
+std::string CreateHybridClusterRequest::getVolumeProtocol()const
+{
+	return volumeProtocol_;
+}
+
+void CreateHybridClusterRequest::setVolumeProtocol(const std::string& volumeProtocol)
+{
+	volumeProtocol_ = volumeProtocol;
+	setParameter("VolumeProtocol", volumeProtocol);
+}
+
+std::string CreateHybridClusterRequest::getOnPremiseVolumeLocalPath()const
+{
+	return onPremiseVolumeLocalPath_;
+}
+
+void CreateHybridClusterRequest::setOnPremiseVolumeLocalPath(const std::string& onPremiseVolumeLocalPath)
+{
+	onPremiseVolumeLocalPath_ = onPremiseVolumeLocalPath;
+	setParameter("OnPremiseVolumeLocalPath", onPremiseVolumeLocalPath);
+}
+
+std::string CreateHybridClusterRequest::getOsTag()const
+{
+	return osTag_;
+}
+
+void CreateHybridClusterRequest::setOsTag(const std::string& osTag)
+{
+	osTag_ = osTag;
+	setParameter("OsTag", osTag);
+}
+
+std::string CreateHybridClusterRequest::getRemoteDirectory()const
+{
+	return remoteDirectory_;
+}
+
+void CreateHybridClusterRequest::setRemoteDirectory(const std::string& remoteDirectory)
+{
+	remoteDirectory_ = remoteDirectory;
+	setParameter("RemoteDirectory", remoteDirectory);
+}
+
+std::string CreateHybridClusterRequest::getVSwitchId()const
+{
+	return vSwitchId_;
+}
+
+void CreateHybridClusterRequest::setVSwitchId(const std::string& vSwitchId)
+{
+	vSwitchId_ = vSwitchId;
+	setParameter("VSwitchId", vSwitchId);
+}
+
 std::string CreateHybridClusterRequest::getNodes()const
 {
 	return nodes_;

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

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

ehpc/src/model/DescribeClusterResult.cc

@@ -105,6 +105,16 @@ void DescribeClusterResult::parse(const std::string &payload)
 			applicationInfoObject.version = value["Version"].asString();
 		clusterInfo_.applications.push_back(applicationInfoObject);
 	}
+	auto allPostInstallScripts = value["PostInstallScripts"]["PostInstallScriptInfo"];
+	for (auto value : allPostInstallScripts)
+	{
+		ClusterInfo::PostInstallScriptInfo postInstallScriptInfoObject;
+		if(!value["Url"].isNull())
+			postInstallScriptInfoObject.url = value["Url"].asString();
+		if(!value["Args"].isNull())
+			postInstallScriptInfoObject.args = value["Args"].asString();
+		clusterInfo_.postInstallScripts.push_back(postInstallScriptInfoObject);
+	}
 	auto ecsInfoNode = clusterInfoNode["EcsInfo"];
 	auto managerNode = ecsInfoNode["Manager"];
 	if(!managerNode["Count"].isNull())

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

ehpc/src/model/DescribeImageGatewayConfigResult.cc

@@ -0,0 +1,75 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/ehpc/model/DescribeImageGatewayConfigResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::EHPC;
+using namespace AlibabaCloud::EHPC::Model;
+
+DescribeImageGatewayConfigResult::DescribeImageGatewayConfigResult() :
+	ServiceResult()
+{}
+
+DescribeImageGatewayConfigResult::DescribeImageGatewayConfigResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+DescribeImageGatewayConfigResult::~DescribeImageGatewayConfigResult()
+{}
+
+void DescribeImageGatewayConfigResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+
+	setRequestId(value["RequestId"].asString());
+	auto imagegwNode = value["Imagegw"];
+	if(!imagegwNode["DefaultImageLocation"].isNull())
+		imagegw_.defaultImageLocation = imagegwNode["DefaultImageLocation"].asString();
+	if(!imagegwNode["PullUpdateTimeout"].isNull())
+		imagegw_.pullUpdateTimeout = std::stol(imagegwNode["PullUpdateTimeout"].asString());
+	if(!imagegwNode["MongoDBURI"].isNull())
+		imagegw_.mongoDBURI = imagegwNode["MongoDBURI"].asString();
+	if(!imagegwNode["ImageExpirationTimeout"].isNull())
+		imagegw_.imageExpirationTimeout = imagegwNode["ImageExpirationTimeout"].asString();
+	if(!imagegwNode["UpdateDateTime"].isNull())
+		imagegw_.updateDateTime = imagegwNode["UpdateDateTime"].asString();
+	auto allLocations = value["Locations"]["LocationInfo"];
+	for (auto value : allLocations)
+	{
+		Imagegw::LocationInfo locationInfoObject;
+		if(!value["Location"].isNull())
+			locationInfoObject.location = value["Location"].asString();
+		if(!value["RemoteType"].isNull())
+			locationInfoObject.remoteType = value["RemoteType"].asString();
+		if(!value["Authentication"].isNull())
+			locationInfoObject.authentication = value["Authentication"].asString();
+		if(!value["URL"].isNull())
+			locationInfoObject.uRL = value["URL"].asString();
+		imagegw_.locations.push_back(locationInfoObject);
+	}
+
+}
+
+DescribeImageGatewayConfigResult::Imagegw DescribeImageGatewayConfigResult::getImagegw()const
+{
+	return imagegw_;
+}
+

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

ehpc/src/model/DescribeImageResult.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/DescribeImageResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::EHPC;
+using namespace AlibabaCloud::EHPC::Model;
+
+DescribeImageResult::DescribeImageResult() :
+	ServiceResult()
+{}
+
+DescribeImageResult::DescribeImageResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+DescribeImageResult::~DescribeImageResult()
+{}
+
+void DescribeImageResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+
+	setRequestId(value["RequestId"].asString());
+	auto imageInfoNode = value["ImageInfo"];
+	if(!imageInfoNode["System"].isNull())
+		imageInfo_.system = imageInfoNode["System"].asString();
+	if(!imageInfoNode["Type"].isNull())
+		imageInfo_.type = imageInfoNode["Type"].asString();
+	if(!imageInfoNode["Status"].isNull())
+		imageInfo_.status = imageInfoNode["Status"].asString();
+	if(!imageInfoNode["ImageId"].isNull())
+		imageInfo_.imageId = imageInfoNode["ImageId"].asString();
+	if(!imageInfoNode["UpdateDateTime"].isNull())
+		imageInfo_.updateDateTime = imageInfoNode["UpdateDateTime"].asString();
+	if(!imageInfoNode["Repository"].isNull())
+		imageInfo_.repository = imageInfoNode["Repository"].asString();
+	if(!imageInfoNode["Tag"].isNull())
+		imageInfo_.tag = imageInfoNode["Tag"].asString();
+
+}
+
+DescribeImageResult::ImageInfo DescribeImageResult::getImageInfo()const
+{
+	return imageInfo_;
+}
+

ehpc/src/model/GetAutoScaleConfigResult.cc

@@ -66,6 +66,10 @@ void GetAutoScaleConfigResult::parse(const std::string &payload)
 		maxNodesInCluster_ = std::stoi(value["MaxNodesInCluster"].asString());
 	if(!value["ExcludeNodes"].isNull())
 		excludeNodes_ = value["ExcludeNodes"].asString();
+	if(!value["SpotStrategy"].isNull())
+		spotStrategy_ = value["SpotStrategy"].asString();
+	if(!value["SpotPriceLimit"].isNull())
+		spotPriceLimit_ = value["SpotPriceLimit"].asString();
 
 }
 
@@ -129,8 +133,18 @@ int GetAutoScaleConfigResult::getShrinkIntervalInMinutes()const
 	return shrinkIntervalInMinutes_;
 }
 
+std::string GetAutoScaleConfigResult::getSpotPriceLimit()const
+{
+	return spotPriceLimit_;
+}
+
 std::string GetAutoScaleConfigResult::getExcludeNodes()const
 {
 	return excludeNodes_;
 }
 
+std::string GetAutoScaleConfigResult::getSpotStrategy()const
+{
+	return spotStrategy_;
+}
+

ehpc/src/model/GetCloudMetricLogsRequest.cc

@@ -0,0 +1,148 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/ehpc/model/GetCloudMetricLogsRequest.h>
+
+using AlibabaCloud::EHPC::Model::GetCloudMetricLogsRequest;
+
+GetCloudMetricLogsRequest::GetCloudMetricLogsRequest() :
+	RpcServiceRequest("ehpc", "2018-04-12", "GetCloudMetricLogs")
+{}
+
+GetCloudMetricLogsRequest::~GetCloudMetricLogsRequest()
+{}
+
+std::string GetCloudMetricLogsRequest::getAggregationType()const
+{
+	return aggregationType_;
+}
+
+void GetCloudMetricLogsRequest::setAggregationType(const std::string& aggregationType)
+{
+	aggregationType_ = aggregationType;
+	setParameter("AggregationType", aggregationType);
+}
+
+std::string GetCloudMetricLogsRequest::getFilter()const
+{
+	return filter_;
+}
+
+void GetCloudMetricLogsRequest::setFilter(const std::string& filter)
+{
+	filter_ = filter;
+	setParameter("Filter", filter);
+}
+
+std::string GetCloudMetricLogsRequest::getMetricCategories()const
+{
+	return metricCategories_;
+}
+
+void GetCloudMetricLogsRequest::setMetricCategories(const std::string& metricCategories)
+{
+	metricCategories_ = metricCategories;
+	setParameter("MetricCategories", metricCategories);
+}
+
+int GetCloudMetricLogsRequest::getLine()const
+{
+	return line_;
+}
+
+void GetCloudMetricLogsRequest::setLine(int line)
+{
+	line_ = line;
+	setParameter("Line", std::to_string(line));
+}
+
+std::string GetCloudMetricLogsRequest::getMetricScope()const
+{
+	return metricScope_;
+}
+
+void GetCloudMetricLogsRequest::setMetricScope(const std::string& metricScope)
+{
+	metricScope_ = metricScope;
+	setParameter("MetricScope", metricScope);
+}
+
+int GetCloudMetricLogsRequest::getFrom()const
+{
+	return from_;
+}
+
+void GetCloudMetricLogsRequest::setFrom(int from)
+{
+	from_ = from;
+	setParameter("From", std::to_string(from));
+}
+
+std::string GetCloudMetricLogsRequest::getClusterId()const
+{
+	return clusterId_;
+}
+
+void GetCloudMetricLogsRequest::setClusterId(const std::string& clusterId)
+{
+	clusterId_ = clusterId;
+	setParameter("ClusterId", clusterId);
+}
+
+int GetCloudMetricLogsRequest::getTo()const
+{
+	return to_;
+}
+
+void GetCloudMetricLogsRequest::setTo(int to)
+{
+	to_ = to;
+	setParameter("To", std::to_string(to));
+}
+
+int GetCloudMetricLogsRequest::getAggregationInterval()const
+{
+	return aggregationInterval_;
+}
+
+void GetCloudMetricLogsRequest::setAggregationInterval(int aggregationInterval)
+{
+	aggregationInterval_ = aggregationInterval;
+	setParameter("AggregationInterval", std::to_string(aggregationInterval));
+}
+
+bool GetCloudMetricLogsRequest::getReverse()const
+{
+	return reverse_;
+}
+
+void GetCloudMetricLogsRequest::setReverse(bool reverse)
+{
+	reverse_ = reverse;
+	setParameter("Reverse", std::to_string(reverse));
+}
+
+std::string GetCloudMetricLogsRequest::getAccessKeyId()const
+{
+	return accessKeyId_;
+}
+
+void GetCloudMetricLogsRequest::setAccessKeyId(const std::string& accessKeyId)
+{
+	accessKeyId_ = accessKeyId;
+	setParameter("AccessKeyId", accessKeyId);
+}
+

ehpc/src/model/GetCloudMetricLogsResult.cc

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

ehpc/src/model/GetHybridClusterConfigRequest.cc

@@ -25,6 +25,17 @@ GetHybridClusterConfigRequest::GetHybridClusterConfigRequest() :
 GetHybridClusterConfigRequest::~GetHybridClusterConfigRequest()
 {}
 
+std::string GetHybridClusterConfigRequest::getNode()const
+{
+	return node_;
+}
+
+void GetHybridClusterConfigRequest::setNode(const std::string& node)
+{
+	node_ = node;
+	setParameter("Node", node);
+}
+
 std::string GetHybridClusterConfigRequest::getClusterId()const
 {
 	return clusterId_;

ehpc/src/model/ListJobsResult.cc

@@ -50,6 +50,8 @@ void ListJobsResult::parse(const std::string &payload)
 			jobsObject.name = value["Name"].asString();
 		if(!value["Owner"].isNull())
 			jobsObject.owner = value["Owner"].asString();
+		if(!value["NodeList"].isNull())
+			jobsObject.nodeList = value["NodeList"].asString();
 		if(!value["Priority"].isNull())
 			jobsObject.priority = std::stoi(value["Priority"].asString());
 		if(!value["State"].isNull())

ehpc/src/model/ModifyImageGatewayConfigRequest.cc

@@ -0,0 +1,144 @@
+/*
+ * 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/ModifyImageGatewayConfigRequest.h>
+
+using AlibabaCloud::EHPC::Model::ModifyImageGatewayConfigRequest;
+
+ModifyImageGatewayConfigRequest::ModifyImageGatewayConfigRequest() :
+	RpcServiceRequest("ehpc", "2018-04-12", "ModifyImageGatewayConfig")
+{}
+
+ModifyImageGatewayConfigRequest::~ModifyImageGatewayConfigRequest()
+{}
+
+std::string ModifyImageGatewayConfigRequest::getDefaultRepoLocation()const
+{
+	return defaultRepoLocation_;
+}
+
+void ModifyImageGatewayConfigRequest::setDefaultRepoLocation(const std::string& defaultRepoLocation)
+{
+	defaultRepoLocation_ = defaultRepoLocation;
+	setParameter("DefaultRepoLocation", defaultRepoLocation);
+}
+
+std::string ModifyImageGatewayConfigRequest::getDBPassword()const
+{
+	return dBPassword_;
+}
+
+void ModifyImageGatewayConfigRequest::setDBPassword(const std::string& dBPassword)
+{
+	dBPassword_ = dBPassword;
+	setParameter("DBPassword", dBPassword);
+}
+
+std::vector<ModifyImageGatewayConfigRequest::Repo> ModifyImageGatewayConfigRequest::getRepo()const
+{
+	return repo_;
+}
+
+void ModifyImageGatewayConfigRequest::setRepo(const std::vector<Repo>& repo)
+{
+	repo_ = repo;
+	int i = 0;
+	for(int i = 0; i!= repo.size(); i++)	{
+		auto obj = repo.at(i);
+		std::string str ="Repo."+ std::to_string(i);
+		setParameter(str + ".Location", obj.location);
+		setParameter(str + ".Auth", obj.auth);
+		setParameter(str + ".URL", obj.uRL);
+	}
+}
+
+std::string ModifyImageGatewayConfigRequest::getDBType()const
+{
+	return dBType_;
+}
+
+void ModifyImageGatewayConfigRequest::setDBType(const std::string& dBType)
+{
+	dBType_ = dBType;
+	setParameter("DBType", dBType);
+}
+
+std::string ModifyImageGatewayConfigRequest::getDBUsername()const
+{
+	return dBUsername_;
+}
+
+void ModifyImageGatewayConfigRequest::setDBUsername(const std::string& dBUsername)
+{
+	dBUsername_ = dBUsername;
+	setParameter("DBUsername", dBUsername);
+}
+
+std::string ModifyImageGatewayConfigRequest::getDBServerInfo()const
+{
+	return dBServerInfo_;
+}
+
+void ModifyImageGatewayConfigRequest::setDBServerInfo(const std::string& dBServerInfo)
+{
+	dBServerInfo_ = dBServerInfo;
+	setParameter("DBServerInfo", dBServerInfo);
+}
+
+int ModifyImageGatewayConfigRequest::getPullUpdateTimeout()const
+{
+	return pullUpdateTimeout_;
+}
+
+void ModifyImageGatewayConfigRequest::setPullUpdateTimeout(int pullUpdateTimeout)
+{
+	pullUpdateTimeout_ = pullUpdateTimeout;
+	setParameter("PullUpdateTimeout", std::to_string(pullUpdateTimeout));
+}
+
+std::string ModifyImageGatewayConfigRequest::getClusterId()const
+{
+	return clusterId_;
+}
+
+void ModifyImageGatewayConfigRequest::setClusterId(const std::string& clusterId)
+{
+	clusterId_ = clusterId;
+	setParameter("ClusterId", clusterId);
+}
+
+std::string ModifyImageGatewayConfigRequest::getAccessKeyId()const
+{
+	return accessKeyId_;
+}
+
+void ModifyImageGatewayConfigRequest::setAccessKeyId(const std::string& accessKeyId)
+{
+	accessKeyId_ = accessKeyId;
+	setParameter("AccessKeyId", accessKeyId);
+}
+
+std::string ModifyImageGatewayConfigRequest::getImageExpirationTimeout()const
+{
+	return imageExpirationTimeout_;
+}
+
+void ModifyImageGatewayConfigRequest::setImageExpirationTimeout(const std::string& imageExpirationTimeout)
+{
+	imageExpirationTimeout_ = imageExpirationTimeout;
+	setParameter("ImageExpirationTimeout", imageExpirationTimeout);
+}
+

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

ehpc/src/model/SetAutoScaleConfigRequest.cc

@@ -69,6 +69,17 @@ void SetAutoScaleConfigRequest::setEnableAutoGrow(bool enableAutoGrow)
 	setParameter("EnableAutoGrow", std::to_string(enableAutoGrow));
 }
 
+std::string SetAutoScaleConfigRequest::getSpotPriceLimit()const
+{
+	return spotPriceLimit_;
+}
+
+void SetAutoScaleConfigRequest::setSpotPriceLimit(const std::string& spotPriceLimit)
+{
+	spotPriceLimit_ = spotPriceLimit;
+	setParameter("SpotPriceLimit", spotPriceLimit);
+}
+
 bool SetAutoScaleConfigRequest::getEnableAutoShrink()const
 {
 	return enableAutoShrink_;
@@ -91,6 +102,17 @@ void SetAutoScaleConfigRequest::setAccessKeyId(const std::string& accessKeyId)
 	setParameter("AccessKeyId", accessKeyId);
 }
 
+std::string SetAutoScaleConfigRequest::getSpotStrategy()const
+{
+	return spotStrategy_;
+}
+
+void SetAutoScaleConfigRequest::setSpotStrategy(const std::string& spotStrategy)
+{
+	spotStrategy_ = spotStrategy;
+	setParameter("SpotStrategy", spotStrategy);
+}
+
 int SetAutoScaleConfigRequest::getMaxNodesInCluster()const
 {
 	return maxNodesInCluster_;