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

28
ehpc/CMakeLists.txt
View File

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

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_

252
ehpc/src/EHPCClient.cc
View File

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

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

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

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

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

95
ehpc/src/model/BindAccountToClusterUserRequest.cc
View File

@@ -1,95 +0,0 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/ehpc/model/BindAccountToClusterUserRequest.h>
using AlibabaCloud::EHPC::Model::BindAccountToClusterUserRequest;
BindAccountToClusterUserRequest::BindAccountToClusterUserRequest() :
RpcServiceRequest("ehpc", "2018-04-12", "BindAccountToClusterUser")
{
setMethod(HttpRequest::Method::Get);
}
BindAccountToClusterUserRequest::~BindAccountToClusterUserRequest()
{}
std::string BindAccountToClusterUserRequest::getUserPwd()const
{
return userPwd_;
}
void BindAccountToClusterUserRequest::setUserPwd(const std::string& userPwd)
{
userPwd_ = userPwd;
setParameter("UserPwd", userPwd);
}
std::string BindAccountToClusterUserRequest::getClusterId()const
{
return clusterId_;
}
void BindAccountToClusterUserRequest::setClusterId(const std::string& clusterId)
{
clusterId_ = clusterId;
setParameter("ClusterId", clusterId);
}
std::string BindAccountToClusterUserRequest::getAccessKeyId()const
{
return accessKeyId_;
}
void BindAccountToClusterUserRequest::setAccessKeyId(const std::string& accessKeyId)
{
accessKeyId_ = accessKeyId;
setParameter("AccessKeyId", accessKeyId);
}
std::string BindAccountToClusterUserRequest::getAccountName()const
{
return accountName_;
}
void BindAccountToClusterUserRequest::setAccountName(const std::string& accountName)
{
accountName_ = accountName;
setParameter("AccountName", accountName);
}
std::string BindAccountToClusterUserRequest::getAccountUid()const
{
return accountUid_;
}
void BindAccountToClusterUserRequest::setAccountUid(const std::string& accountUid)
{
accountUid_ = accountUid;
setParameter("AccountUid", accountUid);
}
std::string BindAccountToClusterUserRequest::getUserName()const
{
return userName_;
}
void BindAccountToClusterUserRequest::setUserName(const std::string& userName)
{
userName_ = userName;
setParameter("UserName", userName);
}

44
ehpc/src/model/BindAccountToClusterUserResult.cc
View File

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

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

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

7
ehpc/src/model/CreateJobFileResult.cc
View File

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

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

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

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

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

77
ehpc/src/model/GetSchedulerInfoRequest.cc Normal file
View File

@@ -0,0 +1,77 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/ehpc/model/GetSchedulerInfoRequest.h>
using AlibabaCloud::EHPC::Model::GetSchedulerInfoRequest;
GetSchedulerInfoRequest::GetSchedulerInfoRequest() :
RpcServiceRequest("ehpc", "2018-04-12", "GetSchedulerInfo")
{
setMethod(HttpRequest::Method::Get);
}
GetSchedulerInfoRequest::~GetSchedulerInfoRequest()
{}
std::string GetSchedulerInfoRequest::getClusterId()const
{
return clusterId_;
}
void GetSchedulerInfoRequest::setClusterId(const std::string& clusterId)
{
clusterId_ = clusterId;
setParameter("ClusterId", clusterId);
}
std::string GetSchedulerInfoRequest::getAccessKeyId()const
{
return accessKeyId_;
}
void GetSchedulerInfoRequest::setAccessKeyId(const std::string& accessKeyId)
{
accessKeyId_ = accessKeyId;
setParameter("AccessKeyId", accessKeyId);
}
std::vector<GetSchedulerInfoRequest::Scheduler> GetSchedulerInfoRequest::getScheduler()const
{
return scheduler_;
}
void GetSchedulerInfoRequest::setScheduler(const std::vector<Scheduler>& scheduler)
{
scheduler_ = scheduler;
for(int dep1 = 0; dep1!= scheduler.size(); dep1++) {
auto schedulerObj = scheduler.at(dep1);
std::string schedulerObjStr = "Scheduler." + std::to_string(dep1 + 1);
setParameter(schedulerObjStr + ".SchedName", schedulerObj.schedName);
}
}
std::string GetSchedulerInfoRequest::getRegionId()const
{
return regionId_;
}
void GetSchedulerInfoRequest::setRegionId(const std::string& regionId)
{
regionId_ = regionId;
setParameter("RegionId", regionId);
}

25
ehpc/src/model/UnbindAccountToClusterUserResult.cc → ehpc/src/model/GetSchedulerInfoResult.cc
View File

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

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

61
ehpc/src/model/ListAccountMappingResult.cc
View File

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

40
ehpc/src/model/ListAvailableFileSystemTypesRequest.cc
View File

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

64
ehpc/src/model/ListAvailableFileSystemTypesResult.cc
View File

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

23
ehpc/src/model/ListNodesNoPagingResult.cc
View File

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

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

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

73
ehpc/src/model/SetJobUserRequest.cc
View File

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

124
ehpc/src/model/SetSchedulerInfoRequest.cc Normal file
View File

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

17
ehpc/src/model/SetJobUserResult.cc → ehpc/src/model/SetSchedulerInfoResult.cc
View File

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

73
ehpc/src/model/UnbindAccountToClusterUserRequest.cc
View File

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