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

Support Round and Interval for ApplyNodes API.

Browse Source
This commit is contained in:
sdk-team
2021-08-19 09:21:30 +00:00
parent 4fc4cdd7b8
commit 16a57f3f23
44 changed files with 571 additions and 1212 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

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

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

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

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

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

63
ehpc/include/alibabacloud/ehpc/model/BindAccountToClusterUserRequest.h
View File

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

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

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

2
ehpc/include/alibabacloud/ehpc/model/CreateJobFileResult.h
View File

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

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

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

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

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

29
ehpc/include/alibabacloud/ehpc/model/UnbindAccountToClusterUserRequest.h → ehpc/include/alibabacloud/ehpc/model/GetSchedulerInfoRequest.h
View File

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

25
ehpc/include/alibabacloud/ehpc/model/ListAccountMappingResult.h → ehpc/include/alibabacloud/ehpc/model/GetSchedulerInfoResult.h
View File

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

51
ehpc/include/alibabacloud/ehpc/model/ListAccountMappingRequest.h
View File

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

48
ehpc/include/alibabacloud/ehpc/model/ListAvailableFileSystemTypesRequest.h
View File

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

58
ehpc/include/alibabacloud/ehpc/model/ListAvailableFileSystemTypesResult.h
View File

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

7
ehpc/include/alibabacloud/ehpc/model/ListNodesNoPagingResult.h
View File

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

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

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

57
ehpc/include/alibabacloud/ehpc/model/SetJobUserRequest.h
View File

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

49
ehpc/include/alibabacloud/ehpc/model/SetJobUserResult.h
View File

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

93
ehpc/include/alibabacloud/ehpc/model/SetSchedulerInfoRequest.h Normal file
View File

@@ -0,0 +1,93 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_EHPC_MODEL_SETSCHEDULERINFOREQUEST_H_
#define ALIBABACLOUD_EHPC_MODEL_SETSCHEDULERINFOREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/ehpc/EHPCExport.h>
namespace AlibabaCloud
{
namespace EHPC
{
namespace Model
{
class ALIBABACLOUD_EHPC_EXPORT SetSchedulerInfoRequest : public RpcServiceRequest
{
public:
struct SlurmInfo
{
int schedInterval;
int backfillInterval;
};
struct Scheduler
{
std::string schedName;
};
struct PbsInfo
{
int schedInterval;
struct ResourceLimit
{
int nodes;
std::string mem;
int cpus;
std::string user;
std::string queue;
};
std::vector<ResourceLimit> resourceLimit;
struct AclLimit
{
std::string aclUsers;
std::string queue;
};
std::vector<AclLimit> aclLimit;
int jobHistoryDuration;
};
public:
SetSchedulerInfoRequest();
~SetSchedulerInfoRequest();
std::vector<SlurmInfo> getSlurmInfo()const;
void setSlurmInfo(const std::vector<SlurmInfo>& slurmInfo);
std::string getClusterId()const;
void setClusterId(const std::string& clusterId);
std::string getAccessKeyId()const;
void setAccessKeyId(const std::string& accessKeyId);
std::vector<Scheduler> getScheduler()const;
void setScheduler(const std::vector<Scheduler>& scheduler);
std::string getRegionId()const;
void setRegionId(const std::string& regionId);
std::vector<PbsInfo> getPbsInfo()const;
void setPbsInfo(const std::vector<PbsInfo>& pbsInfo);
private:
std::vector<SlurmInfo> slurmInfo_;
std::string clusterId_;
std::string accessKeyId_;
std::vector<Scheduler> scheduler_;
std::string regionId_;
std::vector<PbsInfo> pbsInfo_;
};
}
}
}
#endif // !ALIBABACLOUD_EHPC_MODEL_SETSCHEDULERINFOREQUEST_H_

16
ehpc/include/alibabacloud/ehpc/model/BindAccountToClusterUserResult.h → ehpc/include/alibabacloud/ehpc/model/SetSchedulerInfoResult.h
View File

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

49
ehpc/include/alibabacloud/ehpc/model/UnbindAccountToClusterUserResult.h
View File

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