1585346868/aliyun-openapi-cpp-sdk
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

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

Browse Source 
Signed-off-by: yixiong.jxy <yixiong.jxy@alibaba-inc.com>
This commit is contained in:
yixiong.jxy
2018-08-03 10:25:37 +08:00
parent 51b845ce56
commit fe5f64d980
43 changed files with 2134 additions and 57 deletions
Download Patch File Download Diff File Expand all files Collapse all files

3
CHANGELOG
View File

@@ -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

2
VERSION
View File

@@ -1 +1 @@
1.20.5
1.21.0

24
ehpc/CMakeLists.txt
View File

@@ -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

48
ehpc/include/alibabacloud/ehpc/EHPCClient.h
View File

@@ -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;

54
ehpc/include/alibabacloud/ehpc/model/AddLocalNodesRequest.h Normal file
View File

@@ -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_

51
ehpc/include/alibabacloud/ehpc/model/AddLocalNodesResult.h Normal file
View File

@@ -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_

3
ehpc/include/alibabacloud/ehpc/model/CreateClusterRequest.h
View File

@@ -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_;

36
ehpc/include/alibabacloud/ehpc/model/CreateHybridClusterRequest.h
View File

@@ -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_;

60
ehpc/include/alibabacloud/ehpc/model/DeleteImageRequest.h Normal file
View File

@@ -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_

49
ehpc/include/alibabacloud/ehpc/model/DeleteImageResult.h Normal file
View File

@@ -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_

6
ehpc/include/alibabacloud/ehpc/model/DescribeClusterResult.h
View File

@@ -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;

51
ehpc/include/alibabacloud/ehpc/model/DescribeImageGatewayConfigRequest.h Normal file
View File

@@ -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_

67
ehpc/include/alibabacloud/ehpc/model/DescribeImageGatewayConfigResult.h Normal file
View File

@@ -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_

60
ehpc/include/alibabacloud/ehpc/model/DescribeImageRequest.h Normal file
View File

@@ -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_

61
ehpc/include/alibabacloud/ehpc/model/DescribeImageResult.h Normal file
View File

@@ -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_

4
ehpc/include/alibabacloud/ehpc/model/GetAutoScaleConfigResult.h
View File

@@ -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_;
};
}

78
ehpc/include/alibabacloud/ehpc/model/GetCloudMetricLogsRequest.h Normal file
View File

@@ -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_

60
ehpc/include/alibabacloud/ehpc/model/GetCloudMetricLogsResult.h Normal file
View File

@@ -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_

3
ehpc/include/alibabacloud/ehpc/model/GetHybridClusterConfigRequest.h
View File

@@ -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_;

1
ehpc/include/alibabacloud/ehpc/model/ListJobsResult.h
View File

@@ -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;

81
ehpc/include/alibabacloud/ehpc/model/ModifyImageGatewayConfigRequest.h Normal file
View File

@@ -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_

49
ehpc/include/alibabacloud/ehpc/model/ModifyImageGatewayConfigResult.h Normal file
View File

@@ -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_

6
ehpc/include/alibabacloud/ehpc/model/SetAutoScaleConfigRequest.h
View File

@@ -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_;

216
ehpc/src/EHPCClient.cc
View File

@@ -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();

60
ehpc/src/model/AddLocalNodesRequest.cc Normal file
View File

@@ -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);
}

53
ehpc/src/model/AddLocalNodesResult.cc Normal file
View File

@@ -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_;
}

11
ehpc/src/model/CreateClusterRequest.cc
View File

@@ -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_;

132
ehpc/src/model/CreateHybridClusterRequest.cc
View File

@@ -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,6 +91,17 @@ void CreateHybridClusterRequest::setEcsOrderComputeInstanceType(const std::strin
setParameter("EcsOrderComputeInstanceType", ecsOrderComputeInstanceType);
}
std::string CreateHybridClusterRequest::getOnPremiseVolumeRemotePath()const
{
return onPremiseVolumeRemotePath_;
}
void CreateHybridClusterRequest::setOnPremiseVolumeRemotePath(const std::string& onPremiseVolumeRemotePath)
{
onPremiseVolumeRemotePath_ = onPremiseVolumeRemotePath;
setParameter("OnPremiseVolumeRemotePath", onPremiseVolumeRemotePath);
}
std::string CreateHybridClusterRequest::getAccessKeyId()const
{
return accessKeyId_;
@@ -135,17 +113,6 @@ void CreateHybridClusterRequest::setAccessKeyId(const std::string& accessKeyId)
setParameter("AccessKeyId", accessKeyId);
}
std::string CreateHybridClusterRequest::getVSwitchId()const
{
return vSwitchId_;
}
void CreateHybridClusterRequest::setVSwitchId(const std::string& vSwitchId)
{
vSwitchId_ = vSwitchId;
setParameter("VSwitchId", vSwitchId);
}
std::string CreateHybridClusterRequest::getVolumeType()const
{
return volumeType_;
@@ -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_;

82
ehpc/src/model/DeleteImageRequest.cc Normal file
View File

@@ -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);
}

45
ehpc/src/model/DeleteImageResult.cc Normal file
View File

@@ -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());
}

10
ehpc/src/model/DescribeClusterResult.cc
View File

@@ -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())

49
ehpc/src/model/DescribeImageGatewayConfigRequest.cc Normal file
View File

@@ -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);
}

75
ehpc/src/model/DescribeImageGatewayConfigResult.cc Normal file
View File

@@ -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_;
}

82
ehpc/src/model/DescribeImageRequest.cc Normal file
View File

@@ -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);
}

65
ehpc/src/model/DescribeImageResult.cc Normal file
View File

@@ -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_;
}

14
ehpc/src/model/GetAutoScaleConfigResult.cc
View File

@@ -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_;
}

148
ehpc/src/model/GetCloudMetricLogsRequest.cc Normal file
View File

@@ -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);
}

68
ehpc/src/model/GetCloudMetricLogsResult.cc Normal file
View File

@@ -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_;
}

11
ehpc/src/model/GetHybridClusterConfigRequest.cc
View File

@@ -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_;

2
ehpc/src/model/ListJobsResult.cc
View File

@@ -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())

144
ehpc/src/model/ModifyImageGatewayConfigRequest.cc Normal file
View File

@@ -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);
}

45
ehpc/src/model/ModifyImageGatewayConfigResult.cc Normal file
View File

@@ -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());
}

22
ehpc/src/model/SetAutoScaleConfigRequest.cc
View File

@@ -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_;