Support Container for CreateJob.

This commit is contained in:
sdk-team
2024-04-16 03:38:31 +00:00
parent e98b3a0c80
commit e95083301e
566 changed files with 2448 additions and 42930 deletions

File diff suppressed because it is too large Load Diff

View File

@@ -1,81 +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/AddContainerAppRequest.h>
using AlibabaCloud::EHPC::Model::AddContainerAppRequest;
AddContainerAppRequest::AddContainerAppRequest()
: RpcServiceRequest("ehpc", "2018-04-12", "AddContainerApp") {
setMethod(HttpRequest::Method::Get);
}
AddContainerAppRequest::~AddContainerAppRequest() {}
std::string AddContainerAppRequest::getDescription() const {
return description_;
}
void AddContainerAppRequest::setDescription(const std::string &description) {
description_ = description;
setParameter(std::string("Description"), description);
}
std::string AddContainerAppRequest::getRepository() const {
return repository_;
}
void AddContainerAppRequest::setRepository(const std::string &repository) {
repository_ = repository;
setParameter(std::string("Repository"), repository);
}
std::string AddContainerAppRequest::getAccessKeyId() const {
return accessKeyId_;
}
void AddContainerAppRequest::setAccessKeyId(const std::string &accessKeyId) {
accessKeyId_ = accessKeyId;
setParameter(std::string("AccessKeyId"), accessKeyId);
}
std::string AddContainerAppRequest::getContainerType() const {
return containerType_;
}
void AddContainerAppRequest::setContainerType(const std::string &containerType) {
containerType_ = containerType;
setParameter(std::string("ContainerType"), containerType);
}
std::string AddContainerAppRequest::getName() const {
return name_;
}
void AddContainerAppRequest::setName(const std::string &name) {
name_ = name;
setParameter(std::string("Name"), name);
}
std::string AddContainerAppRequest::getImageTag() const {
return imageTag_;
}
void AddContainerAppRequest::setImageTag(const std::string &imageTag) {
imageTag_ = imageTag;
setParameter(std::string("ImageTag"), imageTag);
}

View File

@@ -1,52 +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/AddContainerAppResult.h>
#include <json/json.h>
using namespace AlibabaCloud::EHPC;
using namespace AlibabaCloud::EHPC::Model;
AddContainerAppResult::AddContainerAppResult() :
ServiceResult()
{}
AddContainerAppResult::AddContainerAppResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
AddContainerAppResult::~AddContainerAppResult()
{}
void AddContainerAppResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
auto allContainerId = value["ContainerId"]["ContainerId"];
for (const auto &item : allContainerId)
containerId_.push_back(item.asString());
}
std::vector<std::string> AddContainerAppResult::getContainerId()const
{
return containerId_;
}

View File

@@ -1,85 +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/AddExistedNodesRequest.h>
using AlibabaCloud::EHPC::Model::AddExistedNodesRequest;
AddExistedNodesRequest::AddExistedNodesRequest()
: RpcServiceRequest("ehpc", "2018-04-12", "AddExistedNodes") {
setMethod(HttpRequest::Method::Get);
}
AddExistedNodesRequest::~AddExistedNodesRequest() {}
std::string AddExistedNodesRequest::getImageId() const {
return imageId_;
}
void AddExistedNodesRequest::setImageId(const std::string &imageId) {
imageId_ = imageId;
setParameter(std::string("ImageId"), imageId);
}
std::vector<AddExistedNodesRequest::Instance> AddExistedNodesRequest::getInstance() const {
return instance_;
}
void AddExistedNodesRequest::setInstance(const std::vector<AddExistedNodesRequest::Instance> &instance) {
instance_ = instance;
for(int dep1 = 0; dep1 != instance.size(); dep1++) {
auto instanceObj = instance.at(dep1);
std::string instanceObjStr = std::string("Instance") + "." + std::to_string(dep1 + 1);
setParameter(instanceObjStr + ".Id", instanceObj.id);
}
}
std::string AddExistedNodesRequest::getClusterId() const {
return clusterId_;
}
void AddExistedNodesRequest::setClusterId(const std::string &clusterId) {
clusterId_ = clusterId;
setParameter(std::string("ClusterId"), clusterId);
}
std::string AddExistedNodesRequest::getJobQueue() const {
return jobQueue_;
}
void AddExistedNodesRequest::setJobQueue(const std::string &jobQueue) {
jobQueue_ = jobQueue;
setParameter(std::string("JobQueue"), jobQueue);
}
std::string AddExistedNodesRequest::getAccessKeyId() const {
return accessKeyId_;
}
void AddExistedNodesRequest::setAccessKeyId(const std::string &accessKeyId) {
accessKeyId_ = accessKeyId;
setParameter(std::string("AccessKeyId"), accessKeyId);
}
std::string AddExistedNodesRequest::getImageOwnerAlias() const {
return imageOwnerAlias_;
}
void AddExistedNodesRequest::setImageOwnerAlias(const std::string &imageOwnerAlias) {
imageOwnerAlias_ = imageOwnerAlias;
setParameter(std::string("ImageOwnerAlias"), imageOwnerAlias);
}

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/AddExistedNodesResult.h>
#include <json/json.h>
using namespace AlibabaCloud::EHPC;
using namespace AlibabaCloud::EHPC::Model;
AddExistedNodesResult::AddExistedNodesResult() :
ServiceResult()
{}
AddExistedNodesResult::AddExistedNodesResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
AddExistedNodesResult::~AddExistedNodesResult()
{}
void AddExistedNodesResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
if(!value["TaskId"].isNull())
taskId_ = value["TaskId"].asString();
}
std::string AddExistedNodesResult::getTaskId()const
{
return taskId_;
}

View File

@@ -0,0 +1,87 @@
/*
* 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/AddImageRequest.h>
using AlibabaCloud::EHPC::Model::AddImageRequest;
AddImageRequest::AddImageRequest()
: RpcServiceRequest("ehpc", "2023-07-01", "AddImage") {
setMethod(HttpRequest::Method::Post);
}
AddImageRequest::~AddImageRequest() {}
std::string AddImageRequest::getImageType() const {
return imageType_;
}
void AddImageRequest::setImageType(const std::string &imageType) {
imageType_ = imageType;
setParameter(std::string("ImageType"), imageType);
}
std::string AddImageRequest::getDescription() const {
return description_;
}
void AddImageRequest::setDescription(const std::string &description) {
description_ = description;
setParameter(std::string("Description"), description);
}
std::string AddImageRequest::getVersion() const {
return version_;
}
void AddImageRequest::setVersion(const std::string &version) {
version_ = version;
setParameter(std::string("Version"), version);
}
std::string AddImageRequest::getName() const {
return name_;
}
void AddImageRequest::setName(const std::string &name) {
name_ = name;
setParameter(std::string("Name"), name);
}
AddImageRequest::ContainerImageSpec AddImageRequest::getContainerImageSpec() const {
return containerImageSpec_;
}
void AddImageRequest::setContainerImageSpec(const AddImageRequest::ContainerImageSpec &containerImageSpec) {
containerImageSpec_ = containerImageSpec;
setParameter(std::string("ContainerImageSpec") + ".IsACREnterprise", containerImageSpec.isACREnterprise ? "true" : "false");
setParameter(std::string("ContainerImageSpec") + ".RegistryUrl", containerImageSpec.registryUrl);
setParameter(std::string("ContainerImageSpec") + ".RegistryCredential.Server", containerImageSpec.registryCredential.server);
setParameter(std::string("ContainerImageSpec") + ".RegistryCredential.Password", containerImageSpec.registryCredential.password);
setParameter(std::string("ContainerImageSpec") + ".RegistryCredential.UserName", containerImageSpec.registryCredential.userName);
setParameter(std::string("ContainerImageSpec") + ".RegistryCriId", containerImageSpec.registryCriId);
setParameter(std::string("ContainerImageSpec") + ".IsACRRegistry", containerImageSpec.isACRRegistry ? "true" : "false");
}
AddImageRequest::VMImageSpec AddImageRequest::getVMImageSpec() const {
return vMImageSpec_;
}
void AddImageRequest::setVMImageSpec(const AddImageRequest::VMImageSpec &vMImageSpec) {
vMImageSpec_ = vMImageSpec;
setParameter(std::string("VMImageSpec") + ".ImageId", vMImageSpec.imageId);
}

View File

@@ -14,38 +14,52 @@
* limitations under the License.
*/
#include <alibabacloud/ehpc/model/CreateGWSImageResult.h>
#include <alibabacloud/ehpc/model/AddImageResult.h>
#include <json/json.h>
using namespace AlibabaCloud::EHPC;
using namespace AlibabaCloud::EHPC::Model;
CreateGWSImageResult::CreateGWSImageResult() :
AddImageResult::AddImageResult() :
ServiceResult()
{}
CreateGWSImageResult::CreateGWSImageResult(const std::string &payload) :
AddImageResult::AddImageResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
CreateGWSImageResult::~CreateGWSImageResult()
AddImageResult::~AddImageResult()
{}
void CreateGWSImageResult::parse(const std::string &payload)
void AddImageResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
if(!value["Success"].isNull())
success_ = value["Success"].asString() == "true";
if(!value["ImageId"].isNull())
imageId_ = value["ImageId"].asString();
if(!value["AppId"].isNull())
appId_ = value["AppId"].asString();
}
std::string CreateGWSImageResult::getImageId()const
std::string AddImageResult::getAppId()const
{
return appId_;
}
std::string AddImageResult::getImageId()const
{
return imageId_;
}
bool AddImageResult::getSuccess()const
{
return success_;
}

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.
*/
#include <alibabacloud/ehpc/model/AddLocalNodesRequest.h>
using AlibabaCloud::EHPC::Model::AddLocalNodesRequest;
AddLocalNodesRequest::AddLocalNodesRequest()
: RpcServiceRequest("ehpc", "2018-04-12", "AddLocalNodes") {
setMethod(HttpRequest::Method::Get);
}
AddLocalNodesRequest::~AddLocalNodesRequest() {}
std::string AddLocalNodesRequest::getClusterId() const {
return clusterId_;
}
void AddLocalNodesRequest::setClusterId(const std::string &clusterId) {
clusterId_ = clusterId;
setParameter(std::string("ClusterId"), clusterId);
}
std::string AddLocalNodesRequest::getAccessKeyId() const {
return accessKeyId_;
}
void AddLocalNodesRequest::setAccessKeyId(const std::string &accessKeyId) {
accessKeyId_ = accessKeyId;
setParameter(std::string("AccessKeyId"), accessKeyId);
}
std::string AddLocalNodesRequest::getNodes() const {
return nodes_;
}
void AddLocalNodesRequest::setNodes(const std::string &nodes) {
nodes_ = nodes;
setParameter(std::string("Nodes"), nodes);
}
std::string AddLocalNodesRequest::getQueue() const {
return queue_;
}
void AddLocalNodesRequest::setQueue(const std::string &queue) {
queue_ = queue;
setParameter(std::string("Queue"), queue);
}

View File

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

View File

@@ -1,351 +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/AddNodesRequest.h>
using AlibabaCloud::EHPC::Model::AddNodesRequest;
AddNodesRequest::AddNodesRequest()
: RpcServiceRequest("ehpc", "2018-04-12", "AddNodes") {
setMethod(HttpRequest::Method::Get);
}
AddNodesRequest::~AddNodesRequest() {}
std::string AddNodesRequest::getDnsConfig() const {
return dnsConfig_;
}
void AddNodesRequest::setDnsConfig(const std::string &dnsConfig) {
dnsConfig_ = dnsConfig;
setParameter(std::string("DnsConfig"), dnsConfig);
}
std::string AddNodesRequest::getImageOwnerAlias() const {
return imageOwnerAlias_;
}
void AddNodesRequest::setImageOwnerAlias(const std::string &imageOwnerAlias) {
imageOwnerAlias_ = imageOwnerAlias;
setParameter(std::string("ImageOwnerAlias"), imageOwnerAlias);
}
std::vector<AddNodesRequest::DataDisks> AddNodesRequest::getDataDisks() const {
return dataDisks_;
}
void AddNodesRequest::setDataDisks(const std::vector<AddNodesRequest::DataDisks> &dataDisks) {
dataDisks_ = dataDisks;
for(int dep1 = 0; dep1 != dataDisks.size(); dep1++) {
auto dataDisksObj = dataDisks.at(dep1);
std::string dataDisksObjStr = std::string("DataDisks") + "." + std::to_string(dep1 + 1);
setParameter(dataDisksObjStr + ".DataDiskDeleteWithInstance", dataDisksObj.dataDiskDeleteWithInstance ? "true" : "false");
setParameter(dataDisksObjStr + ".DataDiskEncrypted", dataDisksObj.dataDiskEncrypted ? "true" : "false");
setParameter(dataDisksObjStr + ".DataDiskKMSKeyId", dataDisksObj.dataDiskKMSKeyId);
setParameter(dataDisksObjStr + ".DataDiskSize", std::to_string(dataDisksObj.dataDiskSize));
setParameter(dataDisksObjStr + ".DataDiskCategory", dataDisksObj.dataDiskCategory);
setParameter(dataDisksObjStr + ".DataDiskPerformanceLevel", dataDisksObj.dataDiskPerformanceLevel);
}
}
int AddNodesRequest::getSystemDiskSize() const {
return systemDiskSize_;
}
void AddNodesRequest::setSystemDiskSize(int systemDiskSize) {
systemDiskSize_ = systemDiskSize;
setParameter(std::string("SystemDiskSize"), std::to_string(systemDiskSize));
}
std::string AddNodesRequest::getHostNamePrefix() const {
return hostNamePrefix_;
}
void AddNodesRequest::setHostNamePrefix(const std::string &hostNamePrefix) {
hostNamePrefix_ = hostNamePrefix;
setParameter(std::string("HostNamePrefix"), hostNamePrefix);
}
std::string AddNodesRequest::getComputeSpotInterruptionBehavior() const {
return computeSpotInterruptionBehavior_;
}
void AddNodesRequest::setComputeSpotInterruptionBehavior(const std::string &computeSpotInterruptionBehavior) {
computeSpotInterruptionBehavior_ = computeSpotInterruptionBehavior;
setParameter(std::string("ComputeSpotInterruptionBehavior"), computeSpotInterruptionBehavior);
}
std::string AddNodesRequest::getComputeSpotPriceLimit() const {
return computeSpotPriceLimit_;
}
void AddNodesRequest::setComputeSpotPriceLimit(const std::string &computeSpotPriceLimit) {
computeSpotPriceLimit_ = computeSpotPriceLimit;
setParameter(std::string("ComputeSpotPriceLimit"), computeSpotPriceLimit);
}
int AddNodesRequest::getAutoRenewPeriod() const {
return autoRenewPeriod_;
}
void AddNodesRequest::setAutoRenewPeriod(int autoRenewPeriod) {
autoRenewPeriod_ = autoRenewPeriod;
setParameter(std::string("AutoRenewPeriod"), std::to_string(autoRenewPeriod));
}
int AddNodesRequest::getPeriod() const {
return period_;
}
void AddNodesRequest::setPeriod(int period) {
period_ = period;
setParameter(std::string("Period"), std::to_string(period));
}
int AddNodesRequest::getCount() const {
return count_;
}
void AddNodesRequest::setCount(int count) {
count_ = count;
setParameter(std::string("Count"), std::to_string(count));
}
std::string AddNodesRequest::getComputeSpotStrategy() const {
return computeSpotStrategy_;
}
void AddNodesRequest::setComputeSpotStrategy(const std::string &computeSpotStrategy) {
computeSpotStrategy_ = computeSpotStrategy;
setParameter(std::string("ComputeSpotStrategy"), computeSpotStrategy);
}
std::string AddNodesRequest::getHostNameSuffix() const {
return hostNameSuffix_;
}
void AddNodesRequest::setHostNameSuffix(const std::string &hostNameSuffix) {
hostNameSuffix_ = hostNameSuffix;
setParameter(std::string("HostNameSuffix"), hostNameSuffix);
}
bool AddNodesRequest::getSync() const {
return sync_;
}
void AddNodesRequest::setSync(bool sync) {
sync_ = sync;
setParameter(std::string("Sync"), sync ? "true" : "false");
}
std::string AddNodesRequest::getVSwitchId() const {
return vSwitchId_;
}
void AddNodesRequest::setVSwitchId(const std::string &vSwitchId) {
vSwitchId_ = vSwitchId;
setParameter(std::string("VSwitchId"), vSwitchId);
}
std::string AddNodesRequest::getPeriodUnit() const {
return periodUnit_;
}
void AddNodesRequest::setPeriodUnit(const std::string &periodUnit) {
periodUnit_ = periodUnit;
setParameter(std::string("PeriodUnit"), periodUnit);
}
bool AddNodesRequest::getComputeEnableHt() const {
return computeEnableHt_;
}
void AddNodesRequest::setComputeEnableHt(bool computeEnableHt) {
computeEnableHt_ = computeEnableHt;
setParameter(std::string("ComputeEnableHt"), computeEnableHt ? "true" : "false");
}
std::string AddNodesRequest::getAutoRenew() const {
return autoRenew_;
}
void AddNodesRequest::setAutoRenew(const std::string &autoRenew) {
autoRenew_ = autoRenew;
setParameter(std::string("AutoRenew"), autoRenew);
}
std::string AddNodesRequest::getInternetChargeType() const {
return internetChargeType_;
}
void AddNodesRequest::setInternetChargeType(const std::string &internetChargeType) {
internetChargeType_ = internetChargeType;
setParameter(std::string("InternetChargeType"), internetChargeType);
}
std::string AddNodesRequest::getCreateMode() const {
return createMode_;
}
void AddNodesRequest::setCreateMode(const std::string &createMode) {
createMode_ = createMode;
setParameter(std::string("CreateMode"), createMode);
}
std::string AddNodesRequest::getZoneId() const {
return zoneId_;
}
void AddNodesRequest::setZoneId(const std::string &zoneId) {
zoneId_ = zoneId;
setParameter(std::string("ZoneId"), zoneId);
}
int AddNodesRequest::getInternetMaxBandWidthIn() const {
return internetMaxBandWidthIn_;
}
void AddNodesRequest::setInternetMaxBandWidthIn(int internetMaxBandWidthIn) {
internetMaxBandWidthIn_ = internetMaxBandWidthIn;
setParameter(std::string("InternetMaxBandWidthIn"), std::to_string(internetMaxBandWidthIn));
}
std::string AddNodesRequest::getImageId() const {
return imageId_;
}
void AddNodesRequest::setImageId(const std::string &imageId) {
imageId_ = imageId;
setParameter(std::string("ImageId"), imageId);
}
std::string AddNodesRequest::getSystemDiskLevel() const {
return systemDiskLevel_;
}
void AddNodesRequest::setSystemDiskLevel(const std::string &systemDiskLevel) {
systemDiskLevel_ = systemDiskLevel;
setParameter(std::string("SystemDiskLevel"), systemDiskLevel);
}
std::string AddNodesRequest::getClientToken() const {
return clientToken_;
}
void AddNodesRequest::setClientToken(const std::string &clientToken) {
clientToken_ = clientToken;
setParameter(std::string("ClientToken"), clientToken);
}
bool AddNodesRequest::getAllocatePublicAddress() const {
return allocatePublicAddress_;
}
void AddNodesRequest::setAllocatePublicAddress(bool allocatePublicAddress) {
allocatePublicAddress_ = allocatePublicAddress;
setParameter(std::string("AllocatePublicAddress"), allocatePublicAddress ? "true" : "false");
}
int AddNodesRequest::getInternetMaxBandWidthOut() const {
return internetMaxBandWidthOut_;
}
void AddNodesRequest::setInternetMaxBandWidthOut(int internetMaxBandWidthOut) {
internetMaxBandWidthOut_ = internetMaxBandWidthOut;
setParameter(std::string("InternetMaxBandWidthOut"), std::to_string(internetMaxBandWidthOut));
}
std::string AddNodesRequest::getJobQueue() const {
return jobQueue_;
}
void AddNodesRequest::setJobQueue(const std::string &jobQueue) {
jobQueue_ = jobQueue;
setParameter(std::string("JobQueue"), jobQueue);
}
std::string AddNodesRequest::getAccessKeyId() const {
return accessKeyId_;
}
void AddNodesRequest::setAccessKeyId(const std::string &accessKeyId) {
accessKeyId_ = accessKeyId;
setParameter(std::string("AccessKeyId"), accessKeyId);
}
std::string AddNodesRequest::getSystemDiskType() const {
return systemDiskType_;
}
void AddNodesRequest::setSystemDiskType(const std::string &systemDiskType) {
systemDiskType_ = systemDiskType;
setParameter(std::string("SystemDiskType"), systemDiskType);
}
int AddNodesRequest::getMinCount() const {
return minCount_;
}
void AddNodesRequest::setMinCount(int minCount) {
minCount_ = minCount;
setParameter(std::string("MinCount"), std::to_string(minCount));
}
std::string AddNodesRequest::getInstanceType() const {
return instanceType_;
}
void AddNodesRequest::setInstanceType(const std::string &instanceType) {
instanceType_ = instanceType;
setParameter(std::string("InstanceType"), instanceType);
}
std::string AddNodesRequest::getClusterId() const {
return clusterId_;
}
void AddNodesRequest::setClusterId(const std::string &clusterId) {
clusterId_ = clusterId;
setParameter(std::string("ClusterId"), clusterId);
}
std::string AddNodesRequest::getNetworkInterfaceTrafficMode() const {
return networkInterfaceTrafficMode_;
}
void AddNodesRequest::setNetworkInterfaceTrafficMode(const std::string &networkInterfaceTrafficMode) {
networkInterfaceTrafficMode_ = networkInterfaceTrafficMode;
setParameter(std::string("NetworkInterfaceTrafficMode"), networkInterfaceTrafficMode);
}
int AddNodesRequest::getComputeSpotDuration() const {
return computeSpotDuration_;
}
void AddNodesRequest::setComputeSpotDuration(int computeSpotDuration) {
computeSpotDuration_ = computeSpotDuration;
setParameter(std::string("ComputeSpotDuration"), std::to_string(computeSpotDuration));
}
std::string AddNodesRequest::getEcsChargeType() const {
return ecsChargeType_;
}
void AddNodesRequest::setEcsChargeType(const std::string &ecsChargeType) {
ecsChargeType_ = ecsChargeType;
setParameter(std::string("EcsChargeType"), ecsChargeType);
}

View File

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

View File

@@ -1,81 +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/AddQueueRequest.h>
using AlibabaCloud::EHPC::Model::AddQueueRequest;
AddQueueRequest::AddQueueRequest()
: RpcServiceRequest("ehpc", "2018-04-12", "AddQueue") {
setMethod(HttpRequest::Method::Get);
}
AddQueueRequest::~AddQueueRequest() {}
std::string AddQueueRequest::getDeploymentSetId() const {
return deploymentSetId_;
}
void AddQueueRequest::setDeploymentSetId(const std::string &deploymentSetId) {
deploymentSetId_ = deploymentSetId;
setParameter(std::string("DeploymentSetId"), deploymentSetId);
}
std::string AddQueueRequest::getQueueName() const {
return queueName_;
}
void AddQueueRequest::setQueueName(const std::string &queueName) {
queueName_ = queueName;
setParameter(std::string("QueueName"), queueName);
}
std::string AddQueueRequest::getClusterId() const {
return clusterId_;
}
void AddQueueRequest::setClusterId(const std::string &clusterId) {
clusterId_ = clusterId;
setParameter(std::string("ClusterId"), clusterId);
}
std::string AddQueueRequest::getNetworkInterfaceTrafficMode() const {
return networkInterfaceTrafficMode_;
}
void AddQueueRequest::setNetworkInterfaceTrafficMode(const std::string &networkInterfaceTrafficMode) {
networkInterfaceTrafficMode_ = networkInterfaceTrafficMode;
setParameter(std::string("NetworkInterfaceTrafficMode"), networkInterfaceTrafficMode);
}
std::string AddQueueRequest::getAccessKeyId() const {
return accessKeyId_;
}
void AddQueueRequest::setAccessKeyId(const std::string &accessKeyId) {
accessKeyId_ = accessKeyId;
setParameter(std::string("AccessKeyId"), accessKeyId);
}
bool AddQueueRequest::getUseESS() const {
return useESS_;
}
void AddQueueRequest::setUseESS(bool useESS) {
useESS_ = useESS;
setParameter(std::string("UseESS"), useESS ? "true" : "false");
}

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.
*/
#include <alibabacloud/ehpc/model/AddSecurityGroupRequest.h>
using AlibabaCloud::EHPC::Model::AddSecurityGroupRequest;
AddSecurityGroupRequest::AddSecurityGroupRequest()
: RpcServiceRequest("ehpc", "2018-04-12", "AddSecurityGroup") {
setMethod(HttpRequest::Method::Get);
}
AddSecurityGroupRequest::~AddSecurityGroupRequest() {}
std::string AddSecurityGroupRequest::getClientToken() const {
return clientToken_;
}
void AddSecurityGroupRequest::setClientToken(const std::string &clientToken) {
clientToken_ = clientToken;
setParameter(std::string("ClientToken"), clientToken);
}
std::string AddSecurityGroupRequest::getSecurityGroupId() const {
return securityGroupId_;
}
void AddSecurityGroupRequest::setSecurityGroupId(const std::string &securityGroupId) {
securityGroupId_ = securityGroupId;
setParameter(std::string("SecurityGroupId"), securityGroupId);
}
std::string AddSecurityGroupRequest::getClusterId() const {
return clusterId_;
}
void AddSecurityGroupRequest::setClusterId(const std::string &clusterId) {
clusterId_ = clusterId;
setParameter(std::string("ClusterId"), clusterId);
}
std::string AddSecurityGroupRequest::getAccessKeyId() const {
return accessKeyId_;
}
void AddSecurityGroupRequest::setAccessKeyId(const std::string &accessKeyId) {
accessKeyId_ = accessKeyId;
setParameter(std::string("AccessKeyId"), accessKeyId);
}

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

View File

@@ -1,69 +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/AddUsersRequest.h>
using AlibabaCloud::EHPC::Model::AddUsersRequest;
AddUsersRequest::AddUsersRequest()
: RpcServiceRequest("ehpc", "2018-04-12", "AddUsers") {
setMethod(HttpRequest::Method::Get);
}
AddUsersRequest::~AddUsersRequest() {}
std::string AddUsersRequest::getClusterId() const {
return clusterId_;
}
void AddUsersRequest::setClusterId(const std::string &clusterId) {
clusterId_ = clusterId;
setParameter(std::string("ClusterId"), clusterId);
}
std::string AddUsersRequest::getAccessKeyId() const {
return accessKeyId_;
}
void AddUsersRequest::setAccessKeyId(const std::string &accessKeyId) {
accessKeyId_ = accessKeyId;
setParameter(std::string("AccessKeyId"), accessKeyId);
}
bool AddUsersRequest::getAsync() const {
return async_;
}
void AddUsersRequest::setAsync(bool async) {
async_ = async;
setParameter(std::string("Async"), async ? "true" : "false");
}
std::vector<AddUsersRequest::User> AddUsersRequest::getUser() const {
return user_;
}
void AddUsersRequest::setUser(const std::vector<AddUsersRequest::User> &user) {
user_ = user;
for(int dep1 = 0; dep1 != user.size(); dep1++) {
auto userObj = user.at(dep1);
std::string userObjStr = std::string("User") + "." + std::to_string(dep1 + 1);
setParameter(userObjStr + ".Password", userObj.password);
setParameter(userObjStr + ".Name", userObj.name);
setParameter(userObjStr + ".Group", userObj.group);
}
}

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

View File

@@ -1,304 +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/ApplyNodesRequest.h>
using AlibabaCloud::EHPC::Model::ApplyNodesRequest;
ApplyNodesRequest::ApplyNodesRequest()
: RpcServiceRequest("ehpc", "2018-04-12", "ApplyNodes") {
setMethod(HttpRequest::Method::Get);
}
ApplyNodesRequest::~ApplyNodesRequest() {}
std::string ApplyNodesRequest::getImageId() const {
return imageId_;
}
void ApplyNodesRequest::setImageId(const std::string &imageId) {
imageId_ = imageId;
setParameter(std::string("ImageId"), imageId);
}
int ApplyNodesRequest::getMemory() const {
return memory_;
}
void ApplyNodesRequest::setMemory(int memory) {
memory_ = memory;
setParameter(std::string("Memory"), std::to_string(memory));
}
std::string ApplyNodesRequest::getSystemDiskLevel() const {
return systemDiskLevel_;
}
void ApplyNodesRequest::setSystemDiskLevel(const std::string &systemDiskLevel) {
systemDiskLevel_ = systemDiskLevel;
setParameter(std::string("SystemDiskLevel"), systemDiskLevel);
}
bool ApplyNodesRequest::getAllocatePublicAddress() const {
return allocatePublicAddress_;
}
void ApplyNodesRequest::setAllocatePublicAddress(bool allocatePublicAddress) {
allocatePublicAddress_ = allocatePublicAddress;
setParameter(std::string("AllocatePublicAddress"), allocatePublicAddress ? "true" : "false");
}
int ApplyNodesRequest::getInternetMaxBandWidthOut() const {
return internetMaxBandWidthOut_;
}
void ApplyNodesRequest::setInternetMaxBandWidthOut(int internetMaxBandWidthOut) {
internetMaxBandWidthOut_ = internetMaxBandWidthOut;
setParameter(std::string("InternetMaxBandWidthOut"), std::to_string(internetMaxBandWidthOut));
}
std::string ApplyNodesRequest::getResourceAmountType() const {
return resourceAmountType_;
}
void ApplyNodesRequest::setResourceAmountType(const std::string &resourceAmountType) {
resourceAmountType_ = resourceAmountType;
setParameter(std::string("ResourceAmountType"), resourceAmountType);
}
bool ApplyNodesRequest::getStrictResourceProvision() const {
return strictResourceProvision_;
}
void ApplyNodesRequest::setStrictResourceProvision(bool strictResourceProvision) {
strictResourceProvision_ = strictResourceProvision;
setParameter(std::string("StrictResourceProvision"), strictResourceProvision ? "true" : "false");
}
std::string ApplyNodesRequest::getJobQueue() const {
return jobQueue_;
}
void ApplyNodesRequest::setJobQueue(const std::string &jobQueue) {
jobQueue_ = jobQueue;
setParameter(std::string("JobQueue"), jobQueue);
}
std::string ApplyNodesRequest::getAccessKeyId() const {
return accessKeyId_;
}
void ApplyNodesRequest::setAccessKeyId(const std::string &accessKeyId) {
accessKeyId_ = accessKeyId;
setParameter(std::string("AccessKeyId"), accessKeyId);
}
std::string ApplyNodesRequest::getSystemDiskType() const {
return systemDiskType_;
}
void ApplyNodesRequest::setSystemDiskType(const std::string &systemDiskType) {
systemDiskType_ = systemDiskType;
setParameter(std::string("SystemDiskType"), systemDiskType);
}
std::string ApplyNodesRequest::getUserData() const {
return userData_;
}
void ApplyNodesRequest::setUserData(const std::string &userData) {
userData_ = userData;
setParameter(std::string("UserData"), userData);
}
int ApplyNodesRequest::getCores() const {
return cores_;
}
void ApplyNodesRequest::setCores(int cores) {
cores_ = cores;
setParameter(std::string("Cores"), std::to_string(cores));
}
int ApplyNodesRequest::getSystemDiskSize() const {
return systemDiskSize_;
}
void ApplyNodesRequest::setSystemDiskSize(int systemDiskSize) {
systemDiskSize_ = systemDiskSize;
setParameter(std::string("SystemDiskSize"), std::to_string(systemDiskSize));
}
std::vector<ApplyNodesRequest::ZoneInfos> ApplyNodesRequest::getZoneInfos() const {
return zoneInfos_;
}
void ApplyNodesRequest::setZoneInfos(const std::vector<ApplyNodesRequest::ZoneInfos> &zoneInfos) {
zoneInfos_ = zoneInfos;
for(int dep1 = 0; dep1 != zoneInfos.size(); dep1++) {
auto zoneInfosObj = zoneInfos.at(dep1);
std::string zoneInfosObjStr = std::string("ZoneInfos") + "." + std::to_string(dep1 + 1);
setParameter(zoneInfosObjStr + ".VSwitchId", zoneInfosObj.vSwitchId);
setParameter(zoneInfosObjStr + ".ZoneId", zoneInfosObj.zoneId);
}
}
std::string ApplyNodesRequest::getHostNamePrefix() const {
return hostNamePrefix_;
}
void ApplyNodesRequest::setHostNamePrefix(const std::string &hostNamePrefix) {
hostNamePrefix_ = hostNamePrefix;
setParameter(std::string("HostNamePrefix"), hostNamePrefix);
}
std::vector<ApplyNodesRequest::Tag> ApplyNodesRequest::getTag() const {
return tag_;
}
void ApplyNodesRequest::setTag(const std::vector<ApplyNodesRequest::Tag> &tag) {
tag_ = tag;
for(int dep1 = 0; dep1 != tag.size(); dep1++) {
auto tagObj = tag.at(dep1);
std::string tagObjStr = std::string("Tag") + "." + std::to_string(dep1 + 1);
setParameter(tagObjStr + ".Value", tagObj.value);
setParameter(tagObjStr + ".Key", tagObj.key);
}
}
float ApplyNodesRequest::getComputeSpotPriceLimit() const {
return computeSpotPriceLimit_;
}
void ApplyNodesRequest::setComputeSpotPriceLimit(float computeSpotPriceLimit) {
computeSpotPriceLimit_ = computeSpotPriceLimit;
setParameter(std::string("ComputeSpotPriceLimit"), std::to_string(computeSpotPriceLimit));
}
std::string ApplyNodesRequest::getClusterId() const {
return clusterId_;
}
void ApplyNodesRequest::setClusterId(const std::string &clusterId) {
clusterId_ = clusterId;
setParameter(std::string("ClusterId"), clusterId);
}
std::string ApplyNodesRequest::getComputeSpotStrategy() const {
return computeSpotStrategy_;
}
void ApplyNodesRequest::setComputeSpotStrategy(const std::string &computeSpotStrategy) {
computeSpotStrategy_ = computeSpotStrategy;
setParameter(std::string("ComputeSpotStrategy"), computeSpotStrategy);
}
std::string ApplyNodesRequest::getHostNameSuffix() const {
return hostNameSuffix_;
}
void ApplyNodesRequest::setHostNameSuffix(const std::string &hostNameSuffix) {
hostNameSuffix_ = hostNameSuffix;
setParameter(std::string("HostNameSuffix"), hostNameSuffix);
}
std::string ApplyNodesRequest::getPriorityStrategy() const {
return priorityStrategy_;
}
void ApplyNodesRequest::setPriorityStrategy(const std::string &priorityStrategy) {
priorityStrategy_ = priorityStrategy;
setParameter(std::string("PriorityStrategy"), priorityStrategy);
}
std::string ApplyNodesRequest::getInstanceFamilyLevel() const {
return instanceFamilyLevel_;
}
void ApplyNodesRequest::setInstanceFamilyLevel(const std::string &instanceFamilyLevel) {
instanceFamilyLevel_ = instanceFamilyLevel;
setParameter(std::string("InstanceFamilyLevel"), instanceFamilyLevel);
}
int ApplyNodesRequest::getRound() const {
return round_;
}
void ApplyNodesRequest::setRound(int round) {
round_ = round;
setParameter(std::string("Round"), std::to_string(round));
}
std::string ApplyNodesRequest::getInternetChargeType() const {
return internetChargeType_;
}
void ApplyNodesRequest::setInternetChargeType(const std::string &internetChargeType) {
internetChargeType_ = internetChargeType;
setParameter(std::string("InternetChargeType"), internetChargeType);
}
int ApplyNodesRequest::getInterval() const {
return interval_;
}
void ApplyNodesRequest::setInterval(int interval) {
interval_ = interval;
setParameter(std::string("Interval"), std::to_string(interval));
}
std::vector<ApplyNodesRequest::InstanceTypeModel> ApplyNodesRequest::getInstanceTypeModel() const {
return instanceTypeModel_;
}
void ApplyNodesRequest::setInstanceTypeModel(const std::vector<ApplyNodesRequest::InstanceTypeModel> &instanceTypeModel) {
instanceTypeModel_ = instanceTypeModel;
for(int dep1 = 0; dep1 != instanceTypeModel.size(); dep1++) {
auto instanceTypeModelObj = instanceTypeModel.at(dep1);
std::string instanceTypeModelObjStr = std::string("InstanceTypeModel") + "." + std::to_string(dep1 + 1);
setParameter(instanceTypeModelObjStr + ".MaxPrice", std::to_string(instanceTypeModelObj.maxPrice));
setParameter(instanceTypeModelObjStr + ".TargetImageId", instanceTypeModelObj.targetImageId);
setParameter(instanceTypeModelObjStr + ".InstanceType", instanceTypeModelObj.instanceType);
}
}
int ApplyNodesRequest::getInternetMaxBandWidthIn() const {
return internetMaxBandWidthIn_;
}
void ApplyNodesRequest::setInternetMaxBandWidthIn(int internetMaxBandWidthIn) {
internetMaxBandWidthIn_ = internetMaxBandWidthIn;
setParameter(std::string("InternetMaxBandWidthIn"), std::to_string(internetMaxBandWidthIn));
}
int ApplyNodesRequest::getTargetCapacity() const {
return targetCapacity_;
}
void ApplyNodesRequest::setTargetCapacity(int targetCapacity) {
targetCapacity_ = targetCapacity;
setParameter(std::string("TargetCapacity"), std::to_string(targetCapacity));
}
bool ApplyNodesRequest::getStrictSatisfiedTargetCapacity() const {
return strictSatisfiedTargetCapacity_;
}
void ApplyNodesRequest::setStrictSatisfiedTargetCapacity(bool strictSatisfiedTargetCapacity) {
strictSatisfiedTargetCapacity_ = strictSatisfiedTargetCapacity;
setParameter(std::string("StrictSatisfiedTargetCapacity"), strictSatisfiedTargetCapacity ? "true" : "false");
}

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/ApplyNodesResult.h>
#include <json/json.h>
using namespace AlibabaCloud::EHPC;
using namespace AlibabaCloud::EHPC::Model;
ApplyNodesResult::ApplyNodesResult() :
ServiceResult()
{}
ApplyNodesResult::ApplyNodesResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
ApplyNodesResult::~ApplyNodesResult()
{}
void ApplyNodesResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
auto allInstanceIds = value["InstanceIds"]["InstanceId"];
for (const auto &item : allInstanceIds)
instanceIds_.push_back(item.asString());
if(!value["SatisfiedAmount"].isNull())
satisfiedAmount_ = std::stoi(value["SatisfiedAmount"].asString());
if(!value["TaskId"].isNull())
taskId_ = value["TaskId"].asString();
if(!value["Detail"].isNull())
detail_ = value["Detail"].asString();
}
std::string ApplyNodesResult::getTaskId()const
{
return taskId_;
}
int ApplyNodesResult::getSatisfiedAmount()const
{
return satisfiedAmount_;
}
std::vector<std::string> ApplyNodesResult::getInstanceIds()const
{
return instanceIds_;
}
std::string ApplyNodesResult::getDetail()const
{
return detail_;
}

View File

@@ -1,643 +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/CreateClusterRequest.h>
using AlibabaCloud::EHPC::Model::CreateClusterRequest;
CreateClusterRequest::CreateClusterRequest()
: RpcServiceRequest("ehpc", "2018-04-12", "CreateCluster") {
setMethod(HttpRequest::Method::Get);
}
CreateClusterRequest::~CreateClusterRequest() {}
std::vector<CreateClusterRequest::AdditionalVolumes> CreateClusterRequest::getAdditionalVolumes() const {
return additionalVolumes_;
}
void CreateClusterRequest::setAdditionalVolumes(const std::vector<CreateClusterRequest::AdditionalVolumes> &additionalVolumes) {
additionalVolumes_ = additionalVolumes;
for(int dep1 = 0; dep1 != additionalVolumes.size(); dep1++) {
auto additionalVolumesObj = additionalVolumes.at(dep1);
std::string additionalVolumesObjStr = std::string("AdditionalVolumes") + "." + std::to_string(dep1 + 1);
setParameter(additionalVolumesObjStr + ".VolumeType", additionalVolumesObj.volumeType);
setParameter(additionalVolumesObjStr + ".VolumeMountOption", additionalVolumesObj.volumeMountOption);
setParameter(additionalVolumesObjStr + ".VolumeProtocol", additionalVolumesObj.volumeProtocol);
setParameter(additionalVolumesObjStr + ".LocalDirectory", additionalVolumesObj.localDirectory);
setParameter(additionalVolumesObjStr + ".RemoteDirectory", additionalVolumesObj.remoteDirectory);
for(int dep2 = 0; dep2 != additionalVolumesObj.roles.size(); dep2++) {
auto rolesObj = additionalVolumesObj.roles.at(dep2);
std::string rolesObjStr = additionalVolumesObjStr + ".Roles" + "." + std::to_string(dep2 + 1);
setParameter(rolesObjStr + ".Name", rolesObj.name);
}
setParameter(additionalVolumesObjStr + ".VolumeId", additionalVolumesObj.volumeId);
setParameter(additionalVolumesObjStr + ".VolumeMountpoint", additionalVolumesObj.volumeMountpoint);
setParameter(additionalVolumesObjStr + ".Location", additionalVolumesObj.location);
setParameter(additionalVolumesObjStr + ".JobQueue", additionalVolumesObj.jobQueue);
}
}
std::vector<CreateClusterRequest::AddOns> CreateClusterRequest::getAddOns() const {
return addOns_;
}
void CreateClusterRequest::setAddOns(const std::vector<CreateClusterRequest::AddOns> &addOns) {
addOns_ = addOns;
for(int dep1 = 0; dep1 != addOns.size(); dep1++) {
auto addOnsObj = addOns.at(dep1);
std::string addOnsObjStr = std::string("AddOns") + "." + std::to_string(dep1 + 1);
setParameter(addOnsObjStr + ".DeployMode", addOnsObj.deployMode);
setParameter(addOnsObjStr + ".Port", std::to_string(addOnsObj.port));
setParameter(addOnsObjStr + ".ConfigFile", addOnsObj.configFile);
setParameter(addOnsObjStr + ".DefaultStart", addOnsObj.defaultStart ? "true" : "false");
setParameter(addOnsObjStr + ".Name", addOnsObj.name);
setParameter(addOnsObjStr + ".DBType", addOnsObj.dBType);
setParameter(addOnsObjStr + ".Version", addOnsObj.version);
}
}
std::string CreateClusterRequest::getEcsOrderManagerInstanceType() const {
return ecsOrderManagerInstanceType_;
}
void CreateClusterRequest::setEcsOrderManagerInstanceType(const std::string &ecsOrderManagerInstanceType) {
ecsOrderManagerInstanceType_ = ecsOrderManagerInstanceType;
setParameter(std::string("EcsOrder.Manager.InstanceType"), ecsOrderManagerInstanceType);
}
std::string CreateClusterRequest::getKeyPairName() const {
return keyPairName_;
}
void CreateClusterRequest::setKeyPairName(const std::string &keyPairName) {
keyPairName_ = keyPairName;
setParameter(std::string("KeyPairName"), keyPairName);
}
std::string CreateClusterRequest::getSecurityGroupName() const {
return securityGroupName_;
}
void CreateClusterRequest::setSecurityGroupName(const std::string &securityGroupName) {
securityGroupName_ = securityGroupName;
setParameter(std::string("SecurityGroupName"), securityGroupName);
}
bool CreateClusterRequest::getWithoutNas() const {
return withoutNas_;
}
void CreateClusterRequest::setWithoutNas(bool withoutNas) {
withoutNas_ = withoutNas;
setParameter(std::string("WithoutNas"), withoutNas ? "true" : "false");
}
std::string CreateClusterRequest::getImageOwnerAlias() const {
return imageOwnerAlias_;
}
void CreateClusterRequest::setImageOwnerAlias(const std::string &imageOwnerAlias) {
imageOwnerAlias_ = imageOwnerAlias;
setParameter(std::string("ImageOwnerAlias"), imageOwnerAlias);
}
std::string CreateClusterRequest::getDeployMode() const {
return deployMode_;
}
void CreateClusterRequest::setDeployMode(const std::string &deployMode) {
deployMode_ = deployMode;
setParameter(std::string("DeployMode"), deployMode);
}
int CreateClusterRequest::getEcsOrderManagerCount() const {
return ecsOrderManagerCount_;
}
void CreateClusterRequest::setEcsOrderManagerCount(int ecsOrderManagerCount) {
ecsOrderManagerCount_ = ecsOrderManagerCount;
setParameter(std::string("EcsOrder.Manager.Count"), std::to_string(ecsOrderManagerCount));
}
std::string CreateClusterRequest::getResourceGroupId() const {
return resourceGroupId_;
}
void CreateClusterRequest::setResourceGroupId(const std::string &resourceGroupId) {
resourceGroupId_ = resourceGroupId;
setParameter(std::string("ResourceGroupId"), resourceGroupId);
}
std::string CreateClusterRequest::getPassword() const {
return password_;
}
void CreateClusterRequest::setPassword(const std::string &password) {
password_ = password;
setParameter(std::string("Password"), password);
}
int CreateClusterRequest::getEcsOrderLoginCount() const {
return ecsOrderLoginCount_;
}
void CreateClusterRequest::setEcsOrderLoginCount(int ecsOrderLoginCount) {
ecsOrderLoginCount_ = ecsOrderLoginCount;
setParameter(std::string("EcsOrder.Login.Count"), std::to_string(ecsOrderLoginCount));
}
bool CreateClusterRequest::getWithoutElasticIp() const {
return withoutElasticIp_;
}
void CreateClusterRequest::setWithoutElasticIp(bool withoutElasticIp) {
withoutElasticIp_ = withoutElasticIp;
setParameter(std::string("WithoutElasticIp"), withoutElasticIp ? "true" : "false");
}
std::string CreateClusterRequest::getRemoteVisEnable() const {
return remoteVisEnable_;
}
void CreateClusterRequest::setRemoteVisEnable(const std::string &remoteVisEnable) {
remoteVisEnable_ = remoteVisEnable;
setParameter(std::string("RemoteVisEnable"), remoteVisEnable);
}
int CreateClusterRequest::getSystemDiskSize() const {
return systemDiskSize_;
}
void CreateClusterRequest::setSystemDiskSize(int systemDiskSize) {
systemDiskSize_ = systemDiskSize;
setParameter(std::string("SystemDiskSize"), std::to_string(systemDiskSize));
}
std::vector<CreateClusterRequest::Tag> CreateClusterRequest::getTag() const {
return tag_;
}
void CreateClusterRequest::setTag(const std::vector<CreateClusterRequest::Tag> &tag) {
tag_ = tag;
for(int dep1 = 0; dep1 != tag.size(); dep1++) {
auto tagObj = tag.at(dep1);
std::string tagObjStr = std::string("Tag") + "." + std::to_string(dep1 + 1);
setParameter(tagObjStr + ".Value", tagObj.value);
setParameter(tagObjStr + ".Key", tagObj.key);
}
}
std::string CreateClusterRequest::getComputeSpotPriceLimit() const {
return computeSpotPriceLimit_;
}
void CreateClusterRequest::setComputeSpotPriceLimit(const std::string &computeSpotPriceLimit) {
computeSpotPriceLimit_ = computeSpotPriceLimit;
setParameter(std::string("ComputeSpotPriceLimit"), computeSpotPriceLimit);
}
int CreateClusterRequest::getAutoRenewPeriod() const {
return autoRenewPeriod_;
}
void CreateClusterRequest::setAutoRenewPeriod(int autoRenewPeriod) {
autoRenewPeriod_ = autoRenewPeriod;
setParameter(std::string("AutoRenewPeriod"), std::to_string(autoRenewPeriod));
}
int CreateClusterRequest::getPeriod() const {
return period_;
}
void CreateClusterRequest::setPeriod(int period) {
period_ = period;
setParameter(std::string("Period"), std::to_string(period));
}
std::string CreateClusterRequest::getRemoteDirectory() const {
return remoteDirectory_;
}
void CreateClusterRequest::setRemoteDirectory(const std::string &remoteDirectory) {
remoteDirectory_ = remoteDirectory;
setParameter(std::string("RemoteDirectory"), remoteDirectory);
}
int CreateClusterRequest::getEcsOrderComputeCount() const {
return ecsOrderComputeCount_;
}
void CreateClusterRequest::setEcsOrderComputeCount(int ecsOrderComputeCount) {
ecsOrderComputeCount_ = ecsOrderComputeCount;
setParameter(std::string("EcsOrder.Compute.Count"), std::to_string(ecsOrderComputeCount));
}
std::string CreateClusterRequest::getComputeSpotStrategy() const {
return computeSpotStrategy_;
}
void CreateClusterRequest::setComputeSpotStrategy(const std::string &computeSpotStrategy) {
computeSpotStrategy_ = computeSpotStrategy;
setParameter(std::string("ComputeSpotStrategy"), computeSpotStrategy);
}
std::vector<CreateClusterRequest::PostInstallScript> CreateClusterRequest::getPostInstallScript() const {
return postInstallScript_;
}
void CreateClusterRequest::setPostInstallScript(const std::vector<CreateClusterRequest::PostInstallScript> &postInstallScript) {
postInstallScript_ = postInstallScript;
for(int dep1 = 0; dep1 != postInstallScript.size(); dep1++) {
auto postInstallScriptObj = postInstallScript.at(dep1);
std::string postInstallScriptObjStr = std::string("PostInstallScript") + "." + std::to_string(dep1 + 1);
setParameter(postInstallScriptObjStr + ".Args", postInstallScriptObj.args);
setParameter(postInstallScriptObjStr + ".Url", postInstallScriptObj.url);
}
}
std::vector<std::string> CreateClusterRequest::getRamNodeTypes() const {
return ramNodeTypes_;
}
void CreateClusterRequest::setRamNodeTypes(const std::vector<std::string> &ramNodeTypes) {
ramNodeTypes_ = ramNodeTypes;
}
std::string CreateClusterRequest::getVSwitchId() const {
return vSwitchId_;
}
void CreateClusterRequest::setVSwitchId(const std::string &vSwitchId) {
vSwitchId_ = vSwitchId;
setParameter(std::string("VSwitchId"), vSwitchId);
}
std::string CreateClusterRequest::getPeriodUnit() const {
return periodUnit_;
}
void CreateClusterRequest::setPeriodUnit(const std::string &periodUnit) {
periodUnit_ = periodUnit;
setParameter(std::string("PeriodUnit"), periodUnit);
}
bool CreateClusterRequest::getComputeEnableHt() const {
return computeEnableHt_;
}
void CreateClusterRequest::setComputeEnableHt(bool computeEnableHt) {
computeEnableHt_ = computeEnableHt;
setParameter(std::string("ComputeEnableHt"), computeEnableHt ? "true" : "false");
}
std::string CreateClusterRequest::getAutoRenew() const {
return autoRenew_;
}
void CreateClusterRequest::setAutoRenew(const std::string &autoRenew) {
autoRenew_ = autoRenew;
setParameter(std::string("AutoRenew"), autoRenew);
}
std::string CreateClusterRequest::getDomain() const {
return domain_;
}
void CreateClusterRequest::setDomain(const std::string &domain) {
domain_ = domain;
setParameter(std::string("Domain"), domain);
}
std::string CreateClusterRequest::getName() const {
return name_;
}
void CreateClusterRequest::setName(const std::string &name) {
name_ = name;
setParameter(std::string("Name"), name);
}
std::string CreateClusterRequest::getVolumeId() const {
return volumeId_;
}
void CreateClusterRequest::setVolumeId(const std::string &volumeId) {
volumeId_ = volumeId;
setParameter(std::string("VolumeId"), volumeId);
}
std::string CreateClusterRequest::getZoneId() const {
return zoneId_;
}
void CreateClusterRequest::setZoneId(const std::string &zoneId) {
zoneId_ = zoneId;
setParameter(std::string("ZoneId"), zoneId);
}
std::string CreateClusterRequest::getSccClusterId() const {
return sccClusterId_;
}
void CreateClusterRequest::setSccClusterId(const std::string &sccClusterId) {
sccClusterId_ = sccClusterId;
setParameter(std::string("SccClusterId"), sccClusterId);
}
std::string CreateClusterRequest::getVolumeMountOption() const {
return volumeMountOption_;
}
void CreateClusterRequest::setVolumeMountOption(const std::string &volumeMountOption) {
volumeMountOption_ = volumeMountOption;
setParameter(std::string("VolumeMountOption"), volumeMountOption);
}
std::string CreateClusterRequest::getImageId() const {
return imageId_;
}
void CreateClusterRequest::setImageId(const std::string &imageId) {
imageId_ = imageId;
setParameter(std::string("ImageId"), imageId);
}
std::string CreateClusterRequest::getSystemDiskLevel() const {
return systemDiskLevel_;
}
void CreateClusterRequest::setSystemDiskLevel(const std::string &systemDiskLevel) {
systemDiskLevel_ = systemDiskLevel;
setParameter(std::string("SystemDiskLevel"), systemDiskLevel);
}
std::string CreateClusterRequest::getClientToken() const {
return clientToken_;
}
void CreateClusterRequest::setClientToken(const std::string &clientToken) {
clientToken_ = clientToken;
setParameter(std::string("ClientToken"), clientToken);
}
std::string CreateClusterRequest::getEhpcVersion() const {
return ehpcVersion_;
}
void CreateClusterRequest::setEhpcVersion(const std::string &ehpcVersion) {
ehpcVersion_ = ehpcVersion;
setParameter(std::string("EhpcVersion"), ehpcVersion);
}
std::string CreateClusterRequest::getAccountType() const {
return accountType_;
}
void CreateClusterRequest::setAccountType(const std::string &accountType) {
accountType_ = accountType;
setParameter(std::string("AccountType"), accountType);
}
std::string CreateClusterRequest::getSecurityGroupId() const {
return securityGroupId_;
}
void CreateClusterRequest::setSecurityGroupId(const std::string &securityGroupId) {
securityGroupId_ = securityGroupId;
setParameter(std::string("SecurityGroupId"), securityGroupId);
}
std::string CreateClusterRequest::getDescription() const {
return description_;
}
void CreateClusterRequest::setDescription(const std::string &description) {
description_ = description;
setParameter(std::string("Description"), description);
}
std::string CreateClusterRequest::getEcsOrderComputeInstanceType() const {
return ecsOrderComputeInstanceType_;
}
void CreateClusterRequest::setEcsOrderComputeInstanceType(const std::string &ecsOrderComputeInstanceType) {
ecsOrderComputeInstanceType_ = ecsOrderComputeInstanceType;
setParameter(std::string("EcsOrder.Compute.InstanceType"), ecsOrderComputeInstanceType);
}
std::string CreateClusterRequest::getJobQueue() const {
return jobQueue_;
}
void CreateClusterRequest::setJobQueue(const std::string &jobQueue) {
jobQueue_ = jobQueue;
setParameter(std::string("JobQueue"), jobQueue);
}
std::string CreateClusterRequest::getAccessKeyId() const {
return accessKeyId_;
}
void CreateClusterRequest::setAccessKeyId(const std::string &accessKeyId) {
accessKeyId_ = accessKeyId;
setParameter(std::string("AccessKeyId"), accessKeyId);
}
std::string CreateClusterRequest::getVolumeType() const {
return volumeType_;
}
void CreateClusterRequest::setVolumeType(const std::string &volumeType) {
volumeType_ = volumeType;
setParameter(std::string("VolumeType"), volumeType);
}
std::string CreateClusterRequest::getSystemDiskType() const {
return systemDiskType_;
}
void CreateClusterRequest::setSystemDiskType(const std::string &systemDiskType) {
systemDiskType_ = systemDiskType;
setParameter(std::string("SystemDiskType"), systemDiskType);
}
std::string CreateClusterRequest::getDeploymentSetId() const {
return deploymentSetId_;
}
void CreateClusterRequest::setDeploymentSetId(const std::string &deploymentSetId) {
deploymentSetId_ = deploymentSetId;
setParameter(std::string("DeploymentSetId"), deploymentSetId);
}
std::string CreateClusterRequest::getVolumeProtocol() const {
return volumeProtocol_;
}
void CreateClusterRequest::setVolumeProtocol(const std::string &volumeProtocol) {
volumeProtocol_ = volumeProtocol;
setParameter(std::string("VolumeProtocol"), volumeProtocol);
}
std::string CreateClusterRequest::getClientVersion() const {
return clientVersion_;
}
void CreateClusterRequest::setClientVersion(const std::string &clientVersion) {
clientVersion_ = clientVersion;
setParameter(std::string("ClientVersion"), clientVersion);
}
std::string CreateClusterRequest::getOsTag() const {
return osTag_;
}
void CreateClusterRequest::setOsTag(const std::string &osTag) {
osTag_ = osTag;
setParameter(std::string("OsTag"), osTag);
}
std::string CreateClusterRequest::getClusterVersion() const {
return clusterVersion_;
}
void CreateClusterRequest::setClusterVersion(const std::string &clusterVersion) {
clusterVersion_ = clusterVersion;
setParameter(std::string("ClusterVersion"), clusterVersion);
}
bool CreateClusterRequest::getIsComputeEss() const {
return isComputeEss_;
}
void CreateClusterRequest::setIsComputeEss(bool isComputeEss) {
isComputeEss_ = isComputeEss;
setParameter(std::string("IsComputeEss"), isComputeEss ? "true" : "false");
}
std::string CreateClusterRequest::getRamRoleName() const {
return ramRoleName_;
}
void CreateClusterRequest::setRamRoleName(const std::string &ramRoleName) {
ramRoleName_ = ramRoleName;
setParameter(std::string("RamRoleName"), ramRoleName);
}
std::string CreateClusterRequest::getNetworkInterfaceTrafficMode() const {
return networkInterfaceTrafficMode_;
}
void CreateClusterRequest::setNetworkInterfaceTrafficMode(const std::string &networkInterfaceTrafficMode) {
networkInterfaceTrafficMode_ = networkInterfaceTrafficMode;
setParameter(std::string("NetworkInterfaceTrafficMode"), networkInterfaceTrafficMode);
}
std::string CreateClusterRequest::getPlugin() const {
return plugin_;
}
void CreateClusterRequest::setPlugin(const std::string &plugin) {
plugin_ = plugin;
setParameter(std::string("Plugin"), plugin);
}
std::vector<CreateClusterRequest::Application> CreateClusterRequest::getApplication() const {
return application_;
}
void CreateClusterRequest::setApplication(const std::vector<CreateClusterRequest::Application> &application) {
application_ = application;
for(int dep1 = 0; dep1 != application.size(); dep1++) {
auto applicationObj = application.at(dep1);
std::string applicationObjStr = std::string("Application") + "." + std::to_string(dep1 + 1);
setParameter(applicationObjStr + ".Tag", applicationObj.tag);
}
}
std::string CreateClusterRequest::getEcsChargeType() const {
return ecsChargeType_;
}
void CreateClusterRequest::setEcsChargeType(const std::string &ecsChargeType) {
ecsChargeType_ = ecsChargeType;
setParameter(std::string("EcsChargeType"), ecsChargeType);
}
std::string CreateClusterRequest::getInputFileUrl() const {
return inputFileUrl_;
}
void CreateClusterRequest::setInputFileUrl(const std::string &inputFileUrl) {
inputFileUrl_ = inputFileUrl;
setParameter(std::string("InputFileUrl"), inputFileUrl);
}
std::string CreateClusterRequest::getVpcId() const {
return vpcId_;
}
void CreateClusterRequest::setVpcId(const std::string &vpcId) {
vpcId_ = vpcId;
setParameter(std::string("VpcId"), vpcId);
}
bool CreateClusterRequest::getHaEnable() const {
return haEnable_;
}
void CreateClusterRequest::setHaEnable(bool haEnable) {
haEnable_ = haEnable;
setParameter(std::string("HaEnable"), haEnable ? "true" : "false");
}
bool CreateClusterRequest::getWithoutAgent() const {
return withoutAgent_;
}
void CreateClusterRequest::setWithoutAgent(bool withoutAgent) {
withoutAgent_ = withoutAgent;
setParameter(std::string("WithoutAgent"), withoutAgent ? "true" : "false");
}
std::string CreateClusterRequest::getSchedulerType() const {
return schedulerType_;
}
void CreateClusterRequest::setSchedulerType(const std::string &schedulerType) {
schedulerType_ = schedulerType;
setParameter(std::string("SchedulerType"), schedulerType);
}
std::string CreateClusterRequest::getVolumeMountpoint() const {
return volumeMountpoint_;
}
void CreateClusterRequest::setVolumeMountpoint(const std::string &volumeMountpoint) {
volumeMountpoint_ = volumeMountpoint;
setParameter(std::string("VolumeMountpoint"), volumeMountpoint);
}
std::string CreateClusterRequest::getEcsOrderLoginInstanceType() const {
return ecsOrderLoginInstanceType_;
}
void CreateClusterRequest::setEcsOrderLoginInstanceType(const std::string &ecsOrderLoginInstanceType) {
ecsOrderLoginInstanceType_ = ecsOrderLoginInstanceType;
setParameter(std::string("EcsOrder.Login.InstanceType"), ecsOrderLoginInstanceType);
}

View File

@@ -1,72 +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/CreateGWSClusterRequest.h>
using AlibabaCloud::EHPC::Model::CreateGWSClusterRequest;
CreateGWSClusterRequest::CreateGWSClusterRequest()
: RpcServiceRequest("ehpc", "2018-04-12", "CreateGWSCluster") {
setMethod(HttpRequest::Method::Get);
}
CreateGWSClusterRequest::~CreateGWSClusterRequest() {}
std::string CreateGWSClusterRequest::getAccessKeyId() const {
return accessKeyId_;
}
void CreateGWSClusterRequest::setAccessKeyId(const std::string &accessKeyId) {
accessKeyId_ = accessKeyId;
setParameter(std::string("AccessKeyId"), accessKeyId);
}
std::string CreateGWSClusterRequest::getClusterType() const {
return clusterType_;
}
void CreateGWSClusterRequest::setClusterType(const std::string &clusterType) {
clusterType_ = clusterType;
setParameter(std::string("ClusterType"), clusterType);
}
std::string CreateGWSClusterRequest::getVSwitchId() const {
return vSwitchId_;
}
void CreateGWSClusterRequest::setVSwitchId(const std::string &vSwitchId) {
vSwitchId_ = vSwitchId;
setParameter(std::string("VSwitchId"), vSwitchId);
}
std::string CreateGWSClusterRequest::getVpcId() const {
return vpcId_;
}
void CreateGWSClusterRequest::setVpcId(const std::string &vpcId) {
vpcId_ = vpcId;
setParameter(std::string("VpcId"), vpcId);
}
std::string CreateGWSClusterRequest::getName() const {
return name_;
}
void CreateGWSClusterRequest::setName(const std::string &name) {
name_ = name;
setParameter(std::string("Name"), name);
}

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/CreateGWSClusterResult.h>
#include <json/json.h>
using namespace AlibabaCloud::EHPC;
using namespace AlibabaCloud::EHPC::Model;
CreateGWSClusterResult::CreateGWSClusterResult() :
ServiceResult()
{}
CreateGWSClusterResult::CreateGWSClusterResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
CreateGWSClusterResult::~CreateGWSClusterResult()
{}
void CreateGWSClusterResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
if(!value["ClusterId"].isNull())
clusterId_ = value["ClusterId"].asString();
}
std::string CreateGWSClusterResult::getClusterId()const
{
return clusterId_;
}

View File

@@ -1,54 +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/CreateGWSImageRequest.h>
using AlibabaCloud::EHPC::Model::CreateGWSImageRequest;
CreateGWSImageRequest::CreateGWSImageRequest()
: RpcServiceRequest("ehpc", "2018-04-12", "CreateGWSImage") {
setMethod(HttpRequest::Method::Get);
}
CreateGWSImageRequest::~CreateGWSImageRequest() {}
std::string CreateGWSImageRequest::getAccessKeyId() const {
return accessKeyId_;
}
void CreateGWSImageRequest::setAccessKeyId(const std::string &accessKeyId) {
accessKeyId_ = accessKeyId;
setParameter(std::string("AccessKeyId"), accessKeyId);
}
std::string CreateGWSImageRequest::getInstanceId() const {
return instanceId_;
}
void CreateGWSImageRequest::setInstanceId(const std::string &instanceId) {
instanceId_ = instanceId;
setParameter(std::string("InstanceId"), instanceId);
}
std::string CreateGWSImageRequest::getName() const {
return name_;
}
void CreateGWSImageRequest::setName(const std::string &name) {
name_ = name;
setParameter(std::string("Name"), name);
}

View File

@@ -1,189 +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/CreateGWSInstanceRequest.h>
using AlibabaCloud::EHPC::Model::CreateGWSInstanceRequest;
CreateGWSInstanceRequest::CreateGWSInstanceRequest()
: RpcServiceRequest("ehpc", "2018-04-12", "CreateGWSInstance") {
setMethod(HttpRequest::Method::Get);
}
CreateGWSInstanceRequest::~CreateGWSInstanceRequest() {}
std::string CreateGWSInstanceRequest::getImageId() const {
return imageId_;
}
void CreateGWSInstanceRequest::setImageId(const std::string &imageId) {
imageId_ = imageId;
setParameter(std::string("ImageId"), imageId);
}
bool CreateGWSInstanceRequest::getAllocatePublicAddress() const {
return allocatePublicAddress_;
}
void CreateGWSInstanceRequest::setAllocatePublicAddress(bool allocatePublicAddress) {
allocatePublicAddress_ = allocatePublicAddress;
setParameter(std::string("AllocatePublicAddress"), allocatePublicAddress ? "true" : "false");
}
std::string CreateGWSInstanceRequest::getAppList() const {
return appList_;
}
void CreateGWSInstanceRequest::setAppList(const std::string &appList) {
appList_ = appList;
setParameter(std::string("AppList"), appList);
}
int CreateGWSInstanceRequest::getInternetMaxBandwidthOut() const {
return internetMaxBandwidthOut_;
}
void CreateGWSInstanceRequest::setInternetMaxBandwidthOut(int internetMaxBandwidthOut) {
internetMaxBandwidthOut_ = internetMaxBandwidthOut;
setParameter(std::string("InternetMaxBandwidthOut"), std::to_string(internetMaxBandwidthOut));
}
std::string CreateGWSInstanceRequest::getAccessKeyId() const {
return accessKeyId_;
}
void CreateGWSInstanceRequest::setAccessKeyId(const std::string &accessKeyId) {
accessKeyId_ = accessKeyId;
setParameter(std::string("AccessKeyId"), accessKeyId);
}
std::string CreateGWSInstanceRequest::getSystemDiskCategory() const {
return systemDiskCategory_;
}
void CreateGWSInstanceRequest::setSystemDiskCategory(const std::string &systemDiskCategory) {
systemDiskCategory_ = systemDiskCategory;
setParameter(std::string("SystemDiskCategory"), systemDiskCategory);
}
int CreateGWSInstanceRequest::getSystemDiskSize() const {
return systemDiskSize_;
}
void CreateGWSInstanceRequest::setSystemDiskSize(int systemDiskSize) {
systemDiskSize_ = systemDiskSize;
setParameter(std::string("SystemDiskSize"), std::to_string(systemDiskSize));
}
std::string CreateGWSInstanceRequest::getInstanceType() const {
return instanceType_;
}
void CreateGWSInstanceRequest::setInstanceType(const std::string &instanceType) {
instanceType_ = instanceType;
setParameter(std::string("InstanceType"), instanceType);
}
std::string CreateGWSInstanceRequest::getInstanceChargeType() const {
return instanceChargeType_;
}
void CreateGWSInstanceRequest::setInstanceChargeType(const std::string &instanceChargeType) {
instanceChargeType_ = instanceChargeType;
setParameter(std::string("InstanceChargeType"), instanceChargeType);
}
std::string CreateGWSInstanceRequest::getPeriod() const {
return period_;
}
void CreateGWSInstanceRequest::setPeriod(const std::string &period) {
period_ = period;
setParameter(std::string("Period"), period);
}
std::string CreateGWSInstanceRequest::getClusterId() const {
return clusterId_;
}
void CreateGWSInstanceRequest::setClusterId(const std::string &clusterId) {
clusterId_ = clusterId;
setParameter(std::string("ClusterId"), clusterId);
}
std::string CreateGWSInstanceRequest::getWorkMode() const {
return workMode_;
}
void CreateGWSInstanceRequest::setWorkMode(const std::string &workMode) {
workMode_ = workMode;
setParameter(std::string("WorkMode"), workMode);
}
std::string CreateGWSInstanceRequest::getVSwitchId() const {
return vSwitchId_;
}
void CreateGWSInstanceRequest::setVSwitchId(const std::string &vSwitchId) {
vSwitchId_ = vSwitchId;
setParameter(std::string("VSwitchId"), vSwitchId);
}
std::string CreateGWSInstanceRequest::getPeriodUnit() const {
return periodUnit_;
}
void CreateGWSInstanceRequest::setPeriodUnit(const std::string &periodUnit) {
periodUnit_ = periodUnit;
setParameter(std::string("PeriodUnit"), periodUnit);
}
bool CreateGWSInstanceRequest::getAutoRenew() const {
return autoRenew_;
}
void CreateGWSInstanceRequest::setAutoRenew(bool autoRenew) {
autoRenew_ = autoRenew;
setParameter(std::string("AutoRenew"), autoRenew ? "true" : "false");
}
std::string CreateGWSInstanceRequest::getInternetChargeType() const {
return internetChargeType_;
}
void CreateGWSInstanceRequest::setInternetChargeType(const std::string &internetChargeType) {
internetChargeType_ = internetChargeType;
setParameter(std::string("InternetChargeType"), internetChargeType);
}
std::string CreateGWSInstanceRequest::getName() const {
return name_;
}
void CreateGWSInstanceRequest::setName(const std::string &name) {
name_ = name;
setParameter(std::string("Name"), name);
}
int CreateGWSInstanceRequest::getInternetMaxBandwidthIn() const {
return internetMaxBandwidthIn_;
}
void CreateGWSInstanceRequest::setInternetMaxBandwidthIn(int internetMaxBandwidthIn) {
internetMaxBandwidthIn_ = internetMaxBandwidthIn;
setParameter(std::string("InternetMaxBandwidthIn"), std::to_string(internetMaxBandwidthIn));
}

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/CreateGWSInstanceResult.h>
#include <json/json.h>
using namespace AlibabaCloud::EHPC;
using namespace AlibabaCloud::EHPC::Model;
CreateGWSInstanceResult::CreateGWSInstanceResult() :
ServiceResult()
{}
CreateGWSInstanceResult::CreateGWSInstanceResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
CreateGWSInstanceResult::~CreateGWSInstanceResult()
{}
void CreateGWSInstanceResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
if(!value["InstanceId"].isNull())
instanceId_ = value["InstanceId"].asString();
}
std::string CreateGWSInstanceResult::getInstanceId()const
{
return instanceId_;
}

View File

@@ -1,428 +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/CreateHybridClusterRequest.h>
using AlibabaCloud::EHPC::Model::CreateHybridClusterRequest;
CreateHybridClusterRequest::CreateHybridClusterRequest()
: RpcServiceRequest("ehpc", "2018-04-12", "CreateHybridCluster") {
setMethod(HttpRequest::Method::Get);
}
CreateHybridClusterRequest::~CreateHybridClusterRequest() {}
std::string CreateHybridClusterRequest::getEcsOrderManagerInstanceType() const {
return ecsOrderManagerInstanceType_;
}
void CreateHybridClusterRequest::setEcsOrderManagerInstanceType(const std::string &ecsOrderManagerInstanceType) {
ecsOrderManagerInstanceType_ = ecsOrderManagerInstanceType;
setParameter(std::string("EcsOrder.Manager.InstanceType"), ecsOrderManagerInstanceType);
}
std::string CreateHybridClusterRequest::getKeyPairName() const {
return keyPairName_;
}
void CreateHybridClusterRequest::setKeyPairName(const std::string &keyPairName) {
keyPairName_ = keyPairName;
setParameter(std::string("KeyPairName"), keyPairName);
}
bool CreateHybridClusterRequest::getMultiOs() const {
return multiOs_;
}
void CreateHybridClusterRequest::setMultiOs(bool multiOs) {
multiOs_ = multiOs;
setParameter(std::string("MultiOs"), multiOs ? "true" : "false");
}
std::string CreateHybridClusterRequest::getSecurityGroupName() const {
return securityGroupName_;
}
void CreateHybridClusterRequest::setSecurityGroupName(const std::string &securityGroupName) {
securityGroupName_ = securityGroupName;
setParameter(std::string("SecurityGroupName"), securityGroupName);
}
std::string CreateHybridClusterRequest::getOnPremiseVolumeRemotePath() const {
return onPremiseVolumeRemotePath_;
}
void CreateHybridClusterRequest::setOnPremiseVolumeRemotePath(const std::string &onPremiseVolumeRemotePath) {
onPremiseVolumeRemotePath_ = onPremiseVolumeRemotePath;
setParameter(std::string("OnPremiseVolumeRemotePath"), onPremiseVolumeRemotePath);
}
std::string CreateHybridClusterRequest::getImageOwnerAlias() const {
return imageOwnerAlias_;
}
void CreateHybridClusterRequest::setImageOwnerAlias(const std::string &imageOwnerAlias) {
imageOwnerAlias_ = imageOwnerAlias;
setParameter(std::string("ImageOwnerAlias"), imageOwnerAlias);
}
std::string CreateHybridClusterRequest::getResourceGroupId() const {
return resourceGroupId_;
}
void CreateHybridClusterRequest::setResourceGroupId(const std::string &resourceGroupId) {
resourceGroupId_ = resourceGroupId;
setParameter(std::string("ResourceGroupId"), resourceGroupId);
}
std::string CreateHybridClusterRequest::getPassword() const {
return password_;
}
void CreateHybridClusterRequest::setPassword(const std::string &password) {
password_ = password;
setParameter(std::string("Password"), password);
}
std::string CreateHybridClusterRequest::getHybridClusterOpMode() const {
return hybridClusterOpMode_;
}
void CreateHybridClusterRequest::setHybridClusterOpMode(const std::string &hybridClusterOpMode) {
hybridClusterOpMode_ = hybridClusterOpMode;
setParameter(std::string("HybridClusterOpMode"), hybridClusterOpMode);
}
CreateHybridClusterRequest::WinAdPar CreateHybridClusterRequest::getWinAdPar() const {
return winAdPar_;
}
void CreateHybridClusterRequest::setWinAdPar(const CreateHybridClusterRequest::WinAdPar &winAdPar) {
winAdPar_ = winAdPar;
setParameter(std::string("WinAdPar") + ".AdUser", winAdPar.adUser);
setParameter(std::string("WinAdPar") + ".AdUserPasswd", winAdPar.adUserPasswd);
setParameter(std::string("WinAdPar") + ".AdIp", winAdPar.adIp);
setParameter(std::string("WinAdPar") + ".AdDc", winAdPar.adDc);
}
float CreateHybridClusterRequest::getComputeSpotPriceLimit() const {
return computeSpotPriceLimit_;
}
void CreateHybridClusterRequest::setComputeSpotPriceLimit(float computeSpotPriceLimit) {
computeSpotPriceLimit_ = computeSpotPriceLimit;
setParameter(std::string("ComputeSpotPriceLimit"), std::to_string(computeSpotPriceLimit));
}
std::string CreateHybridClusterRequest::getOnPremiseVolumeLocalPath() const {
return onPremiseVolumeLocalPath_;
}
void CreateHybridClusterRequest::setOnPremiseVolumeLocalPath(const std::string &onPremiseVolumeLocalPath) {
onPremiseVolumeLocalPath_ = onPremiseVolumeLocalPath;
setParameter(std::string("OnPremiseVolumeLocalPath"), onPremiseVolumeLocalPath);
}
std::string CreateHybridClusterRequest::getRemoteDirectory() const {
return remoteDirectory_;
}
void CreateHybridClusterRequest::setRemoteDirectory(const std::string &remoteDirectory) {
remoteDirectory_ = remoteDirectory;
setParameter(std::string("RemoteDirectory"), remoteDirectory);
}
std::string CreateHybridClusterRequest::getComputeSpotStrategy() const {
return computeSpotStrategy_;
}
void CreateHybridClusterRequest::setComputeSpotStrategy(const std::string &computeSpotStrategy) {
computeSpotStrategy_ = computeSpotStrategy;
setParameter(std::string("ComputeSpotStrategy"), computeSpotStrategy);
}
std::vector<CreateHybridClusterRequest::PostInstallScript> CreateHybridClusterRequest::getPostInstallScript() const {
return postInstallScript_;
}
void CreateHybridClusterRequest::setPostInstallScript(const std::vector<CreateHybridClusterRequest::PostInstallScript> &postInstallScript) {
postInstallScript_ = postInstallScript;
for(int dep1 = 0; dep1 != postInstallScript.size(); dep1++) {
auto postInstallScriptObj = postInstallScript.at(dep1);
std::string postInstallScriptObjStr = std::string("PostInstallScript") + "." + std::to_string(dep1 + 1);
setParameter(postInstallScriptObjStr + ".Args", postInstallScriptObj.args);
setParameter(postInstallScriptObjStr + ".Url", postInstallScriptObj.url);
}
}
std::string CreateHybridClusterRequest::getVSwitchId() const {
return vSwitchId_;
}
void CreateHybridClusterRequest::setVSwitchId(const std::string &vSwitchId) {
vSwitchId_ = vSwitchId;
setParameter(std::string("VSwitchId"), vSwitchId);
}
std::string CreateHybridClusterRequest::getDomain() const {
return domain_;
}
void CreateHybridClusterRequest::setDomain(const std::string &domain) {
domain_ = domain;
setParameter(std::string("Domain"), domain);
}
std::string CreateHybridClusterRequest::getName() const {
return name_;
}
void CreateHybridClusterRequest::setName(const std::string &name) {
name_ = name;
setParameter(std::string("Name"), name);
}
std::string CreateHybridClusterRequest::getVolumeId() const {
return volumeId_;
}
void CreateHybridClusterRequest::setVolumeId(const std::string &volumeId) {
volumeId_ = volumeId;
setParameter(std::string("VolumeId"), volumeId);
}
std::string CreateHybridClusterRequest::getZoneId() const {
return zoneId_;
}
void CreateHybridClusterRequest::setZoneId(const std::string &zoneId) {
zoneId_ = zoneId;
setParameter(std::string("ZoneId"), zoneId);
}
std::string CreateHybridClusterRequest::getImageId() const {
return imageId_;
}
void CreateHybridClusterRequest::setImageId(const std::string &imageId) {
imageId_ = imageId;
setParameter(std::string("ImageId"), imageId);
}
std::string CreateHybridClusterRequest::getClientToken() const {
return clientToken_;
}
void CreateHybridClusterRequest::setClientToken(const std::string &clientToken) {
clientToken_ = clientToken;
setParameter(std::string("ClientToken"), clientToken);
}
std::string CreateHybridClusterRequest::getEhpcVersion() const {
return ehpcVersion_;
}
void CreateHybridClusterRequest::setEhpcVersion(const std::string &ehpcVersion) {
ehpcVersion_ = ehpcVersion;
setParameter(std::string("EhpcVersion"), ehpcVersion);
}
std::string CreateHybridClusterRequest::getSecurityGroupId() const {
return securityGroupId_;
}
void CreateHybridClusterRequest::setSecurityGroupId(const std::string &securityGroupId) {
securityGroupId_ = securityGroupId;
setParameter(std::string("SecurityGroupId"), securityGroupId);
}
std::string CreateHybridClusterRequest::getDescription() const {
return description_;
}
void CreateHybridClusterRequest::setDescription(const std::string &description) {
description_ = description;
setParameter(std::string("Description"), description);
}
std::string CreateHybridClusterRequest::getEcsOrderComputeInstanceType() const {
return ecsOrderComputeInstanceType_;
}
void CreateHybridClusterRequest::setEcsOrderComputeInstanceType(const std::string &ecsOrderComputeInstanceType) {
ecsOrderComputeInstanceType_ = ecsOrderComputeInstanceType;
setParameter(std::string("EcsOrder.Compute.InstanceType"), ecsOrderComputeInstanceType);
}
CreateHybridClusterRequest::OpenldapPar CreateHybridClusterRequest::getOpenldapPar() const {
return openldapPar_;
}
void CreateHybridClusterRequest::setOpenldapPar(const CreateHybridClusterRequest::OpenldapPar &openldapPar) {
openldapPar_ = openldapPar;
setParameter(std::string("OpenldapPar") + ".FallbackHomeDir", openldapPar.fallbackHomeDir);
setParameter(std::string("OpenldapPar") + ".BaseDn", openldapPar.baseDn);
setParameter(std::string("OpenldapPar") + ".LdapServerIp", openldapPar.ldapServerIp);
}
std::string CreateHybridClusterRequest::getJobQueue() const {
return jobQueue_;
}
void CreateHybridClusterRequest::setJobQueue(const std::string &jobQueue) {
jobQueue_ = jobQueue;
setParameter(std::string("JobQueue"), jobQueue);
}
std::string CreateHybridClusterRequest::getAccessKeyId() const {
return accessKeyId_;
}
void CreateHybridClusterRequest::setAccessKeyId(const std::string &accessKeyId) {
accessKeyId_ = accessKeyId;
setParameter(std::string("AccessKeyId"), accessKeyId);
}
std::string CreateHybridClusterRequest::getVolumeType() const {
return volumeType_;
}
void CreateHybridClusterRequest::setVolumeType(const std::string &volumeType) {
volumeType_ = volumeType;
setParameter(std::string("VolumeType"), volumeType);
}
std::string CreateHybridClusterRequest::getOnPremiseVolumeMountPoint() const {
return onPremiseVolumeMountPoint_;
}
void CreateHybridClusterRequest::setOnPremiseVolumeMountPoint(const std::string &onPremiseVolumeMountPoint) {
onPremiseVolumeMountPoint_ = onPremiseVolumeMountPoint;
setParameter(std::string("OnPremiseVolumeMountPoint"), onPremiseVolumeMountPoint);
}
std::string CreateHybridClusterRequest::getOnPremiseVolumeProtocol() const {
return onPremiseVolumeProtocol_;
}
void CreateHybridClusterRequest::setOnPremiseVolumeProtocol(const std::string &onPremiseVolumeProtocol) {
onPremiseVolumeProtocol_ = onPremiseVolumeProtocol;
setParameter(std::string("OnPremiseVolumeProtocol"), onPremiseVolumeProtocol);
}
std::string CreateHybridClusterRequest::getVolumeProtocol() const {
return volumeProtocol_;
}
void CreateHybridClusterRequest::setVolumeProtocol(const std::string &volumeProtocol) {
volumeProtocol_ = volumeProtocol;
setParameter(std::string("VolumeProtocol"), volumeProtocol);
}
std::string CreateHybridClusterRequest::getClientVersion() const {
return clientVersion_;
}
void CreateHybridClusterRequest::setClientVersion(const std::string &clientVersion) {
clientVersion_ = clientVersion;
setParameter(std::string("ClientVersion"), clientVersion);
}
std::string CreateHybridClusterRequest::getOsTag() const {
return osTag_;
}
void CreateHybridClusterRequest::setOsTag(const std::string &osTag) {
osTag_ = osTag;
setParameter(std::string("OsTag"), osTag);
}
std::vector<CreateHybridClusterRequest::Nodes> CreateHybridClusterRequest::getNodes() const {
return nodes_;
}
void CreateHybridClusterRequest::setNodes(const std::vector<CreateHybridClusterRequest::Nodes> &nodes) {
nodes_ = nodes;
for(int dep1 = 0; dep1 != nodes.size(); dep1++) {
auto nodesObj = nodes.at(dep1);
std::string nodesObjStr = std::string("Nodes") + "." + std::to_string(dep1 + 1);
setParameter(nodesObjStr + ".IpAddress", nodesObj.ipAddress);
setParameter(nodesObjStr + ".HostName", nodesObj.hostName);
setParameter(nodesObjStr + ".Role", nodesObj.role);
setParameter(nodesObjStr + ".SchedulerType", nodesObj.schedulerType);
setParameter(nodesObjStr + ".AccountType", nodesObj.accountType);
setParameter(nodesObjStr + ".Dir", nodesObj.dir);
}
}
std::string CreateHybridClusterRequest::getPlugin() const {
return plugin_;
}
void CreateHybridClusterRequest::setPlugin(const std::string &plugin) {
plugin_ = plugin;
setParameter(std::string("Plugin"), plugin);
}
std::vector<CreateHybridClusterRequest::Application> CreateHybridClusterRequest::getApplication() const {
return application_;
}
void CreateHybridClusterRequest::setApplication(const std::vector<CreateHybridClusterRequest::Application> &application) {
application_ = application;
for(int dep1 = 0; dep1 != application.size(); dep1++) {
auto applicationObj = application.at(dep1);
std::string applicationObjStr = std::string("Application") + "." + std::to_string(dep1 + 1);
setParameter(applicationObjStr + ".Tag", applicationObj.tag);
}
}
std::string CreateHybridClusterRequest::getVpcId() const {
return vpcId_;
}
void CreateHybridClusterRequest::setVpcId(const std::string &vpcId) {
vpcId_ = vpcId;
setParameter(std::string("VpcId"), vpcId);
}
std::string CreateHybridClusterRequest::getVolumeMountpoint() const {
return volumeMountpoint_;
}
void CreateHybridClusterRequest::setVolumeMountpoint(const std::string &volumeMountpoint) {
volumeMountpoint_ = volumeMountpoint;
setParameter(std::string("VolumeMountpoint"), volumeMountpoint);
}
bool CreateHybridClusterRequest::getSchedulerPreInstall() const {
return schedulerPreInstall_;
}
void CreateHybridClusterRequest::setSchedulerPreInstall(bool schedulerPreInstall) {
schedulerPreInstall_ = schedulerPreInstall;
setParameter(std::string("SchedulerPreInstall"), schedulerPreInstall ? "true" : "false");
}
std::string CreateHybridClusterRequest::getLocation() const {
return location_;
}
void CreateHybridClusterRequest::setLocation(const std::string &location) {
location_ = location;
setParameter(std::string("Location"), location);
}

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.
*/
#include <alibabacloud/ehpc/model/CreateHybridClusterResult.h>
#include <json/json.h>
using namespace AlibabaCloud::EHPC;
using namespace AlibabaCloud::EHPC::Model;
CreateHybridClusterResult::CreateHybridClusterResult() :
ServiceResult()
{}
CreateHybridClusterResult::CreateHybridClusterResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
CreateHybridClusterResult::~CreateHybridClusterResult()
{}
void CreateHybridClusterResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
if(!value["TaskId"].isNull())
taskId_ = value["TaskId"].asString();
if(!value["ClusterId"].isNull())
clusterId_ = value["ClusterId"].asString();
}
std::string CreateHybridClusterResult::getTaskId()const
{
return taskId_;
}
std::string CreateHybridClusterResult::getClusterId()const
{
return clusterId_;
}

View File

@@ -1,90 +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/CreateJobFileRequest.h>
using AlibabaCloud::EHPC::Model::CreateJobFileRequest;
CreateJobFileRequest::CreateJobFileRequest()
: RpcServiceRequest("ehpc", "2018-04-12", "CreateJobFile") {
setMethod(HttpRequest::Method::Get);
}
CreateJobFileRequest::~CreateJobFileRequest() {}
std::string CreateJobFileRequest::getTargetFile() const {
return targetFile_;
}
void CreateJobFileRequest::setTargetFile(const std::string &targetFile) {
targetFile_ = targetFile;
setParameter(std::string("TargetFile"), targetFile);
}
std::string CreateJobFileRequest::getRunasUserPassword() const {
return runasUserPassword_;
}
void CreateJobFileRequest::setRunasUserPassword(const std::string &runasUserPassword) {
runasUserPassword_ = runasUserPassword;
setParameter(std::string("RunasUserPassword"), runasUserPassword);
}
std::string CreateJobFileRequest::getRunasUser() const {
return runasUser_;
}
void CreateJobFileRequest::setRunasUser(const std::string &runasUser) {
runasUser_ = runasUser;
setParameter(std::string("RunasUser"), runasUser);
}
std::string CreateJobFileRequest::getClusterId() const {
return clusterId_;
}
void CreateJobFileRequest::setClusterId(const std::string &clusterId) {
clusterId_ = clusterId;
setParameter(std::string("ClusterId"), clusterId);
}
std::string CreateJobFileRequest::getContent() const {
return content_;
}
void CreateJobFileRequest::setContent(const std::string &content) {
content_ = content;
setParameter(std::string("Content"), content);
}
std::string CreateJobFileRequest::getAccessKeyId() const {
return accessKeyId_;
}
void CreateJobFileRequest::setAccessKeyId(const std::string &accessKeyId) {
accessKeyId_ = accessKeyId;
setParameter(std::string("AccessKeyId"), accessKeyId);
}
bool CreateJobFileRequest::getAsync() const {
return async_;
}
void CreateJobFileRequest::setAsync(bool async) {
async_ = async;
setParameter(std::string("Async"), async ? "true" : "false");
}

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

View File

@@ -0,0 +1,125 @@
/*
* 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/CreateJobRequest.h>
using AlibabaCloud::EHPC::Model::CreateJobRequest;
CreateJobRequest::CreateJobRequest()
: RpcServiceRequest("ehpc", "2023-07-01", "CreateJob") {
setMethod(HttpRequest::Method::Post);
}
CreateJobRequest::~CreateJobRequest() {}
CreateJobRequest::MonitorPolicy CreateJobRequest::getMonitorPolicy() const {
return monitorPolicy_;
}
void CreateJobRequest::setMonitorPolicy(const CreateJobRequest::MonitorPolicy &monitorPolicy) {
monitorPolicy_ = monitorPolicy;
for(int dep1 = 0; dep1 != monitorPolicy.notificationSpec.mNSTopic.size(); dep1++) {
for(int dep2 = 0; dep2 != monitorPolicy.notificationSpec.mNSTopic[dep1].event.size(); dep2++) {
setParameter(std::string("MonitorPolicy") + ".NotificationSpec.MNSTopic." + std::to_string(dep1 + 1) + ".Event." + std::to_string(dep2 + 1), monitorPolicy.notificationSpec.mNSTopic[dep1].event[dep2]);
}
setParameter(std::string("MonitorPolicy") + ".NotificationSpec.MNSTopic." + std::to_string(dep1 + 1) + ".TopicLocation", monitorPolicy.notificationSpec.mNSTopic[dep1].topicLocation);
}
}
std::string CreateJobRequest::getJobDescription() const {
return jobDescription_;
}
void CreateJobRequest::setJobDescription(const std::string &jobDescription) {
jobDescription_ = jobDescription;
setParameter(std::string("JobDescription"), jobDescription);
}
CreateJobRequest::DeploymentPolicy CreateJobRequest::getDeploymentPolicy() const {
return deploymentPolicy_;
}
void CreateJobRequest::setDeploymentPolicy(const CreateJobRequest::DeploymentPolicy &deploymentPolicy) {
deploymentPolicy_ = deploymentPolicy;
setParameter(std::string("DeploymentPolicy") + ".AllocationSpec", deploymentPolicy.allocationSpec);
setParameter(std::string("DeploymentPolicy") + ".Network.EnableERI", deploymentPolicy.network.enableERI ? "true" : "false");
for(int dep1 = 0; dep1 != deploymentPolicy.network.vswitch.size(); dep1++) {
setParameter(std::string("DeploymentPolicy") + ".Network.Vswitch." + std::to_string(dep1 + 1), deploymentPolicy.network.vswitch[dep1]);
}
setParameter(std::string("DeploymentPolicy") + ".Network.EnableENIMapping", deploymentPolicy.network.enableENIMapping ? "true" : "false");
}
std::string CreateJobRequest::getJobName() const {
return jobName_;
}
void CreateJobRequest::setJobName(const std::string &jobName) {
jobName_ = jobName;
setParameter(std::string("JobName"), jobName);
}
std::vector<CreateJobRequest::Tasks> CreateJobRequest::getTasks() const {
return tasks_;
}
void CreateJobRequest::setTasks(const std::vector<CreateJobRequest::Tasks> &tasks) {
tasks_ = tasks;
for(int dep1 = 0; dep1 != tasks.size(); dep1++) {
setParameter(std::string("Tasks") + "." + std::to_string(dep1 + 1) + ".TaskSustainable", tasks[dep1].taskSustainable ? "true" : "false");
setParameter(std::string("Tasks") + "." + std::to_string(dep1 + 1) + ".TaskName", tasks[dep1].taskName);
setParameter(std::string("Tasks") + "." + std::to_string(dep1 + 1) + ".ExecutorPolicy.MaxCount", std::to_string(tasks[dep1].executorPolicy.maxCount));
setParameter(std::string("Tasks") + "." + std::to_string(dep1 + 1) + ".ExecutorPolicy.ArraySpec.IndexStart", std::to_string(tasks[dep1].executorPolicy.arraySpec.indexStart));
setParameter(std::string("Tasks") + "." + std::to_string(dep1 + 1) + ".ExecutorPolicy.ArraySpec.IndexStep", std::to_string(tasks[dep1].executorPolicy.arraySpec.indexStep));
setParameter(std::string("Tasks") + "." + std::to_string(dep1 + 1) + ".ExecutorPolicy.ArraySpec.IndexEnd", std::to_string(tasks[dep1].executorPolicy.arraySpec.indexEnd));
for(int dep2 = 0; dep2 != tasks[dep1].taskSpec.volumeMount.size(); dep2++) {
setParameter(std::string("Tasks") + "." + std::to_string(dep1 + 1) + ".TaskSpec.VolumeMount." + std::to_string(dep2 + 1) + ".MountOptions", tasks[dep1].taskSpec.volumeMount[dep2].mountOptions);
setParameter(std::string("Tasks") + "." + std::to_string(dep1 + 1) + ".TaskSpec.VolumeMount." + std::to_string(dep2 + 1) + ".VolumeDriver", tasks[dep1].taskSpec.volumeMount[dep2].volumeDriver);
setParameter(std::string("Tasks") + "." + std::to_string(dep1 + 1) + ".TaskSpec.VolumeMount." + std::to_string(dep2 + 1) + ".MountPath", tasks[dep1].taskSpec.volumeMount[dep2].mountPath);
}
setParameter(std::string("Tasks") + "." + std::to_string(dep1 + 1) + ".TaskSpec.RetryPolicy.RetryCount", std::to_string(tasks[dep1].taskSpec.retryPolicy.retryCount));
for(int dep2 = 0; dep2 != tasks[dep1].taskSpec.retryPolicy.exitCodeActions.size(); dep2++) {
setParameter(std::string("Tasks") + "." + std::to_string(dep1 + 1) + ".TaskSpec.RetryPolicy.ExitCodeActions." + std::to_string(dep2 + 1) + ".Action", tasks[dep1].taskSpec.retryPolicy.exitCodeActions[dep2].action);
setParameter(std::string("Tasks") + "." + std::to_string(dep1 + 1) + ".TaskSpec.RetryPolicy.ExitCodeActions." + std::to_string(dep2 + 1) + ".ExitCode", tasks[dep1].taskSpec.retryPolicy.exitCodeActions[dep2].exitCode);
}
setParameter(std::string("Tasks") + "." + std::to_string(dep1 + 1) + ".TaskSpec.Resource.Cores", std::to_string(tasks[dep1].taskSpec.resource.cores));
setParameter(std::string("Tasks") + "." + std::to_string(dep1 + 1) + ".TaskSpec.Resource.Memory", std::to_string(tasks[dep1].taskSpec.resource.memory));
for(int dep2 = 0; dep2 != tasks[dep1].taskSpec.resource.disks.size(); dep2++) {
setParameter(std::string("Tasks") + "." + std::to_string(dep1 + 1) + ".TaskSpec.Resource.Disks." + std::to_string(dep2 + 1) + ".Size", std::to_string(tasks[dep1].taskSpec.resource.disks[dep2].size));
setParameter(std::string("Tasks") + "." + std::to_string(dep1 + 1) + ".TaskSpec.Resource.Disks." + std::to_string(dep2 + 1) + ".Type", tasks[dep1].taskSpec.resource.disks[dep2].type);
}
setParameter(std::string("Tasks") + "." + std::to_string(dep1 + 1) + ".TaskSpec.Resource.EnableHT", tasks[dep1].taskSpec.resource.enableHT ? "true" : "false");
setParameter(std::string("Tasks") + "." + std::to_string(dep1 + 1) + ".TaskSpec.TaskDuration", tasks[dep1].taskSpec.taskDuration);
for(int dep2 = 0; dep2 != tasks[dep1].taskSpec.taskExecutor.size(); dep2++) {
setParameter(std::string("Tasks") + "." + std::to_string(dep1 + 1) + ".TaskSpec.TaskExecutor." + std::to_string(dep2 + 1) + ".Container.Image", tasks[dep1].taskSpec.taskExecutor[dep2].container.image);
for(int dep3 = 0; dep3 != tasks[dep1].taskSpec.taskExecutor[dep2].container.environmentVars.size(); dep3++) {
setParameter(std::string("Tasks") + "." + std::to_string(dep1 + 1) + ".TaskSpec.TaskExecutor." + std::to_string(dep2 + 1) + ".Container.EnvironmentVars." + std::to_string(dep3 + 1) + ".Name", tasks[dep1].taskSpec.taskExecutor[dep2].container.environmentVars[dep3].name);
setParameter(std::string("Tasks") + "." + std::to_string(dep1 + 1) + ".TaskSpec.TaskExecutor." + std::to_string(dep2 + 1) + ".Container.EnvironmentVars." + std::to_string(dep3 + 1) + ".Value", tasks[dep1].taskSpec.taskExecutor[dep2].container.environmentVars[dep3].value);
}
setParameter(std::string("Tasks") + "." + std::to_string(dep1 + 1) + ".TaskSpec.TaskExecutor." + std::to_string(dep2 + 1) + ".Container.WorkingDir", tasks[dep1].taskSpec.taskExecutor[dep2].container.workingDir);
for(int dep3 = 0; dep3 != tasks[dep1].taskSpec.taskExecutor[dep2].container.command.size(); dep3++) {
setParameter(std::string("Tasks") + "." + std::to_string(dep1 + 1) + ".TaskSpec.TaskExecutor." + std::to_string(dep2 + 1) + ".Container.Command." + std::to_string(dep3 + 1), tasks[dep1].taskSpec.taskExecutor[dep2].container.command[dep3]);
}
setParameter(std::string("Tasks") + "." + std::to_string(dep1 + 1) + ".TaskSpec.TaskExecutor." + std::to_string(dep2 + 1) + ".VM.Image", tasks[dep1].taskSpec.taskExecutor[dep2].vM.image);
setParameter(std::string("Tasks") + "." + std::to_string(dep1 + 1) + ".TaskSpec.TaskExecutor." + std::to_string(dep2 + 1) + ".VM.PrologScript", tasks[dep1].taskSpec.taskExecutor[dep2].vM.prologScript);
for(int dep3 = 0; dep3 != tasks[dep1].taskSpec.taskExecutor[dep2].vM.environmentVars.size(); dep3++) {
setParameter(std::string("Tasks") + "." + std::to_string(dep1 + 1) + ".TaskSpec.TaskExecutor." + std::to_string(dep2 + 1) + ".VM.EnvironmentVars." + std::to_string(dep3 + 1) + ".Name", tasks[dep1].taskSpec.taskExecutor[dep2].vM.environmentVars[dep3].name);
setParameter(std::string("Tasks") + "." + std::to_string(dep1 + 1) + ".TaskSpec.TaskExecutor." + std::to_string(dep2 + 1) + ".VM.EnvironmentVars." + std::to_string(dep3 + 1) + ".Value", tasks[dep1].taskSpec.taskExecutor[dep2].vM.environmentVars[dep3].value);
}
setParameter(std::string("Tasks") + "." + std::to_string(dep1 + 1) + ".TaskSpec.TaskExecutor." + std::to_string(dep2 + 1) + ".VM.Script", tasks[dep1].taskSpec.taskExecutor[dep2].vM.script);
}
}
}

View File

@@ -14,26 +14,26 @@
* limitations under the License.
*/
#include <alibabacloud/ehpc/model/SubmitJobResult.h>
#include <alibabacloud/ehpc/model/CreateJobResult.h>
#include <json/json.h>
using namespace AlibabaCloud::EHPC;
using namespace AlibabaCloud::EHPC::Model;
SubmitJobResult::SubmitJobResult() :
CreateJobResult::CreateJobResult() :
ServiceResult()
{}
SubmitJobResult::SubmitJobResult(const std::string &payload) :
CreateJobResult::CreateJobResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
SubmitJobResult::~SubmitJobResult()
CreateJobResult::~CreateJobResult()
{}
void SubmitJobResult::parse(const std::string &payload)
void CreateJobResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
@@ -44,7 +44,7 @@ void SubmitJobResult::parse(const std::string &payload)
}
std::string SubmitJobResult::getJobId()const
std::string CreateJobResult::getJobId()const
{
return jobId_;
}

View File

@@ -1,216 +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/CreateJobTemplateRequest.h>
using AlibabaCloud::EHPC::Model::CreateJobTemplateRequest;
CreateJobTemplateRequest::CreateJobTemplateRequest()
: RpcServiceRequest("ehpc", "2018-04-12", "CreateJobTemplate") {
setMethod(HttpRequest::Method::Get);
}
CreateJobTemplateRequest::~CreateJobTemplateRequest() {}
std::string CreateJobTemplateRequest::getStderrRedirectPath() const {
return stderrRedirectPath_;
}
void CreateJobTemplateRequest::setStderrRedirectPath(const std::string &stderrRedirectPath) {
stderrRedirectPath_ = stderrRedirectPath;
setParameter(std::string("StderrRedirectPath"), stderrRedirectPath);
}
std::string CreateJobTemplateRequest::getClockTime() const {
return clockTime_;
}
void CreateJobTemplateRequest::setClockTime(const std::string &clockTime) {
clockTime_ = clockTime;
setParameter(std::string("ClockTime"), clockTime);
}
std::string CreateJobTemplateRequest::getCommandLine() const {
return commandLine_;
}
void CreateJobTemplateRequest::setCommandLine(const std::string &commandLine) {
commandLine_ = commandLine;
setParameter(std::string("CommandLine"), commandLine);
}
std::string CreateJobTemplateRequest::getAccessKeyId() const {
return accessKeyId_;
}
void CreateJobTemplateRequest::setAccessKeyId(const std::string &accessKeyId) {
accessKeyId_ = accessKeyId;
setParameter(std::string("AccessKeyId"), accessKeyId);
}
std::string CreateJobTemplateRequest::getArrayRequest() const {
return arrayRequest_;
}
void CreateJobTemplateRequest::setArrayRequest(const std::string &arrayRequest) {
arrayRequest_ = arrayRequest;
setParameter(std::string("ArrayRequest"), arrayRequest);
}
std::string CreateJobTemplateRequest::getUnzipCmd() const {
return unzipCmd_;
}
void CreateJobTemplateRequest::setUnzipCmd(const std::string &unzipCmd) {
unzipCmd_ = unzipCmd;
setParameter(std::string("UnzipCmd"), unzipCmd);
}
std::string CreateJobTemplateRequest::getPackagePath() const {
return packagePath_;
}
void CreateJobTemplateRequest::setPackagePath(const std::string &packagePath) {
packagePath_ = packagePath;
setParameter(std::string("PackagePath"), packagePath);
}
std::string CreateJobTemplateRequest::getMem() const {
return mem_;
}
void CreateJobTemplateRequest::setMem(const std::string &mem) {
mem_ = mem;
setParameter(std::string("Mem"), mem);
}
std::string CreateJobTemplateRequest::getStdoutRedirectPath() const {
return stdoutRedirectPath_;
}
void CreateJobTemplateRequest::setStdoutRedirectPath(const std::string &stdoutRedirectPath) {
stdoutRedirectPath_ = stdoutRedirectPath;
setParameter(std::string("StdoutRedirectPath"), stdoutRedirectPath);
}
std::string CreateJobTemplateRequest::getVariables() const {
return variables_;
}
void CreateJobTemplateRequest::setVariables(const std::string &variables) {
variables_ = variables;
setParameter(std::string("Variables"), variables);
}
std::string CreateJobTemplateRequest::getRunasUser() const {
return runasUser_;
}
void CreateJobTemplateRequest::setRunasUser(const std::string &runasUser) {
runasUser_ = runasUser;
setParameter(std::string("RunasUser"), runasUser);
}
bool CreateJobTemplateRequest::getReRunable() const {
return reRunable_;
}
void CreateJobTemplateRequest::setReRunable(bool reRunable) {
reRunable_ = reRunable;
setParameter(std::string("ReRunable"), reRunable ? "true" : "false");
}
int CreateJobTemplateRequest::getThread() const {
return thread_;
}
void CreateJobTemplateRequest::setThread(int thread) {
thread_ = thread;
setParameter(std::string("Thread"), std::to_string(thread));
}
int CreateJobTemplateRequest::getPriority() const {
return priority_;
}
void CreateJobTemplateRequest::setPriority(int priority) {
priority_ = priority;
setParameter(std::string("Priority"), std::to_string(priority));
}
int CreateJobTemplateRequest::getGpu() const {
return gpu_;
}
void CreateJobTemplateRequest::setGpu(int gpu) {
gpu_ = gpu;
setParameter(std::string("Gpu"), std::to_string(gpu));
}
bool CreateJobTemplateRequest::getWithUnzipCmd() const {
return withUnzipCmd_;
}
void CreateJobTemplateRequest::setWithUnzipCmd(bool withUnzipCmd) {
withUnzipCmd_ = withUnzipCmd;
setParameter(std::string("WithUnzipCmd"), withUnzipCmd ? "true" : "false");
}
int CreateJobTemplateRequest::getNode() const {
return node_;
}
void CreateJobTemplateRequest::setNode(int node) {
node_ = node;
setParameter(std::string("Node"), std::to_string(node));
}
int CreateJobTemplateRequest::getTask() const {
return task_;
}
void CreateJobTemplateRequest::setTask(int task) {
task_ = task;
setParameter(std::string("Task"), std::to_string(task));
}
std::string CreateJobTemplateRequest::getInputFileUrl() const {
return inputFileUrl_;
}
void CreateJobTemplateRequest::setInputFileUrl(const std::string &inputFileUrl) {
inputFileUrl_ = inputFileUrl;
setParameter(std::string("InputFileUrl"), inputFileUrl);
}
std::string CreateJobTemplateRequest::getName() const {
return name_;
}
void CreateJobTemplateRequest::setName(const std::string &name) {
name_ = name;
setParameter(std::string("Name"), name);
}
std::string CreateJobTemplateRequest::getQueue() const {
return queue_;
}
void CreateJobTemplateRequest::setQueue(const std::string &queue) {
queue_ = queue;
setParameter(std::string("Queue"), queue);
}

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/CreateJobTemplateResult.h>
#include <json/json.h>
using namespace AlibabaCloud::EHPC;
using namespace AlibabaCloud::EHPC::Model;
CreateJobTemplateResult::CreateJobTemplateResult() :
ServiceResult()
{}
CreateJobTemplateResult::CreateJobTemplateResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
CreateJobTemplateResult::~CreateJobTemplateResult()
{}
void CreateJobTemplateResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
if(!value["TemplateId"].isNull())
templateId_ = value["TemplateId"].asString();
}
std::string CreateJobTemplateResult::getTemplateId()const
{
return templateId_;
}

View File

@@ -1,54 +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/DeleteClusterRequest.h>
using AlibabaCloud::EHPC::Model::DeleteClusterRequest;
DeleteClusterRequest::DeleteClusterRequest()
: RpcServiceRequest("ehpc", "2018-04-12", "DeleteCluster") {
setMethod(HttpRequest::Method::Get);
}
DeleteClusterRequest::~DeleteClusterRequest() {}
std::string DeleteClusterRequest::getClusterId() const {
return clusterId_;
}
void DeleteClusterRequest::setClusterId(const std::string &clusterId) {
clusterId_ = clusterId;
setParameter(std::string("ClusterId"), clusterId);
}
std::string DeleteClusterRequest::getAccessKeyId() const {
return accessKeyId_;
}
void DeleteClusterRequest::setAccessKeyId(const std::string &accessKeyId) {
accessKeyId_ = accessKeyId;
setParameter(std::string("AccessKeyId"), accessKeyId);
}
std::string DeleteClusterRequest::getReleaseInstance() const {
return releaseInstance_;
}
void DeleteClusterRequest::setReleaseInstance(const std::string &releaseInstance) {
releaseInstance_ = releaseInstance;
setParameter(std::string("ReleaseInstance"), releaseInstance);
}

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/DeleteClusterResult.h>
#include <json/json.h>
using namespace AlibabaCloud::EHPC;
using namespace AlibabaCloud::EHPC::Model;
DeleteClusterResult::DeleteClusterResult() :
ServiceResult()
{}
DeleteClusterResult::DeleteClusterResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
DeleteClusterResult::~DeleteClusterResult()
{}
void DeleteClusterResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
if(!value["TaskId"].isNull())
taskId_ = value["TaskId"].asString();
}
std::string DeleteClusterResult::getTaskId()const
{
return taskId_;
}

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.
*/
#include <alibabacloud/ehpc/model/DeleteContainerAppsRequest.h>
using AlibabaCloud::EHPC::Model::DeleteContainerAppsRequest;
DeleteContainerAppsRequest::DeleteContainerAppsRequest()
: RpcServiceRequest("ehpc", "2018-04-12", "DeleteContainerApps") {
setMethod(HttpRequest::Method::Get);
}
DeleteContainerAppsRequest::~DeleteContainerAppsRequest() {}
std::vector<DeleteContainerAppsRequest::ContainerApp> DeleteContainerAppsRequest::getContainerApp() const {
return containerApp_;
}
void DeleteContainerAppsRequest::setContainerApp(const std::vector<DeleteContainerAppsRequest::ContainerApp> &containerApp) {
containerApp_ = containerApp;
for(int dep1 = 0; dep1 != containerApp.size(); dep1++) {
auto containerAppObj = containerApp.at(dep1);
std::string containerAppObjStr = std::string("ContainerApp") + "." + std::to_string(dep1 + 1);
setParameter(containerAppObjStr + ".Id", containerAppObj.id);
}
}
std::string DeleteContainerAppsRequest::getAccessKeyId() const {
return accessKeyId_;
}
void DeleteContainerAppsRequest::setAccessKeyId(const std::string &accessKeyId) {
accessKeyId_ = accessKeyId;
setParameter(std::string("AccessKeyId"), accessKeyId);
}

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

View File

@@ -1,45 +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/DeleteGWSClusterRequest.h>
using AlibabaCloud::EHPC::Model::DeleteGWSClusterRequest;
DeleteGWSClusterRequest::DeleteGWSClusterRequest()
: RpcServiceRequest("ehpc", "2018-04-12", "DeleteGWSCluster") {
setMethod(HttpRequest::Method::Get);
}
DeleteGWSClusterRequest::~DeleteGWSClusterRequest() {}
std::string DeleteGWSClusterRequest::getClusterId() const {
return clusterId_;
}
void DeleteGWSClusterRequest::setClusterId(const std::string &clusterId) {
clusterId_ = clusterId;
setParameter(std::string("ClusterId"), clusterId);
}
std::string DeleteGWSClusterRequest::getAccessKeyId() const {
return accessKeyId_;
}
void DeleteGWSClusterRequest::setAccessKeyId(const std::string &accessKeyId) {
accessKeyId_ = accessKeyId;
setParameter(std::string("AccessKeyId"), accessKeyId);
}

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

View File

@@ -1,45 +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/DeleteGWSInstanceRequest.h>
using AlibabaCloud::EHPC::Model::DeleteGWSInstanceRequest;
DeleteGWSInstanceRequest::DeleteGWSInstanceRequest()
: RpcServiceRequest("ehpc", "2018-04-12", "DeleteGWSInstance") {
setMethod(HttpRequest::Method::Get);
}
DeleteGWSInstanceRequest::~DeleteGWSInstanceRequest() {}
std::string DeleteGWSInstanceRequest::getAccessKeyId() const {
return accessKeyId_;
}
void DeleteGWSInstanceRequest::setAccessKeyId(const std::string &accessKeyId) {
accessKeyId_ = accessKeyId;
setParameter(std::string("AccessKeyId"), accessKeyId);
}
std::string DeleteGWSInstanceRequest::getInstanceId() const {
return instanceId_;
}
void DeleteGWSInstanceRequest::setInstanceId(const std::string &instanceId) {
instanceId_ = instanceId;
setParameter(std::string("InstanceId"), instanceId);
}

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

View File

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

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

View File

@@ -1,45 +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/DeleteJobTemplatesRequest.h>
using AlibabaCloud::EHPC::Model::DeleteJobTemplatesRequest;
DeleteJobTemplatesRequest::DeleteJobTemplatesRequest()
: RpcServiceRequest("ehpc", "2018-04-12", "DeleteJobTemplates") {
setMethod(HttpRequest::Method::Get);
}
DeleteJobTemplatesRequest::~DeleteJobTemplatesRequest() {}
std::string DeleteJobTemplatesRequest::getTemplates() const {
return templates_;
}
void DeleteJobTemplatesRequest::setTemplates(const std::string &templates) {
templates_ = templates;
setParameter(std::string("Templates"), templates);
}
std::string DeleteJobTemplatesRequest::getAccessKeyId() const {
return accessKeyId_;
}
void DeleteJobTemplatesRequest::setAccessKeyId(const std::string &accessKeyId) {
accessKeyId_ = accessKeyId;
setParameter(std::string("AccessKeyId"), accessKeyId);
}

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

View File

@@ -19,45 +19,37 @@
using AlibabaCloud::EHPC::Model::DeleteJobsRequest;
DeleteJobsRequest::DeleteJobsRequest()
: RpcServiceRequest("ehpc", "2018-04-12", "DeleteJobs") {
setMethod(HttpRequest::Method::Get);
: RpcServiceRequest("ehpc", "2023-07-01", "DeleteJobs") {
setMethod(HttpRequest::Method::Post);
}
DeleteJobsRequest::~DeleteJobsRequest() {}
std::string DeleteJobsRequest::getJobs() const {
return jobs_;
std::vector<DeleteJobsRequest::JobSpec> DeleteJobsRequest::getJobSpec() const {
return jobSpec_;
}
void DeleteJobsRequest::setJobs(const std::string &jobs) {
jobs_ = jobs;
setParameter(std::string("Jobs"), jobs);
void DeleteJobsRequest::setJobSpec(const std::vector<DeleteJobsRequest::JobSpec> &jobSpec) {
jobSpec_ = jobSpec;
for(int dep1 = 0; dep1 != jobSpec.size(); dep1++) {
setParameter(std::string("JobSpec") + "." + std::to_string(dep1 + 1) + ".JobId", jobSpec[dep1].jobId);
for(int dep2 = 0; dep2 != jobSpec[dep1].taskSpec.size(); dep2++) {
setParameter(std::string("JobSpec") + "." + std::to_string(dep1 + 1) + ".TaskSpec." + std::to_string(dep2 + 1) + ".TaskName", jobSpec[dep1].taskSpec[dep2].taskName);
for(int dep3 = 0; dep3 != jobSpec[dep1].taskSpec[dep2].arrayIndex.size(); dep3++) {
setParameter(std::string("JobSpec") + "." + std::to_string(dep1 + 1) + ".TaskSpec." + std::to_string(dep2 + 1) + ".ArrayIndex." + std::to_string(dep3 + 1), std::to_string(jobSpec[dep1].taskSpec[dep2].arrayIndex[dep3]));
}
}
}
}
std::string DeleteJobsRequest::getClusterId() const {
return clusterId_;
std::vector<DeleteJobsRequest::std::string> DeleteJobsRequest::getExecutorIds() const {
return executorIds_;
}
void DeleteJobsRequest::setClusterId(const std::string &clusterId) {
clusterId_ = clusterId;
setParameter(std::string("ClusterId"), clusterId);
}
std::string DeleteJobsRequest::getAccessKeyId() const {
return accessKeyId_;
}
void DeleteJobsRequest::setAccessKeyId(const std::string &accessKeyId) {
accessKeyId_ = accessKeyId;
setParameter(std::string("AccessKeyId"), accessKeyId);
}
bool DeleteJobsRequest::getAsync() const {
return async_;
}
void DeleteJobsRequest::setAsync(bool async) {
async_ = async;
setParameter(std::string("Async"), async ? "true" : "false");
void DeleteJobsRequest::setExecutorIds(const std::vector<DeleteJobsRequest::std::string> &executorIds) {
executorIds_ = executorIds;
for(int dep1 = 0; dep1 != executorIds.size(); dep1++) {
setParameter(std::string("ExecutorIds") + "." + std::to_string(dep1 + 1), executorIds[dep1]);
}
}

View File

@@ -1,54 +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/DeleteLocalImageRequest.h>
using AlibabaCloud::EHPC::Model::DeleteLocalImageRequest;
DeleteLocalImageRequest::DeleteLocalImageRequest()
: RpcServiceRequest("ehpc", "2018-04-12", "DeleteLocalImage") {
setMethod(HttpRequest::Method::Get);
}
DeleteLocalImageRequest::~DeleteLocalImageRequest() {}
std::string DeleteLocalImageRequest::getClusterId() const {
return clusterId_;
}
void DeleteLocalImageRequest::setClusterId(const std::string &clusterId) {
clusterId_ = clusterId;
setParameter(std::string("ClusterId"), clusterId);
}
std::string DeleteLocalImageRequest::getContainerType() const {
return containerType_;
}
void DeleteLocalImageRequest::setContainerType(const std::string &containerType) {
containerType_ = containerType;
setParameter(std::string("ContainerType"), containerType);
}
std::string DeleteLocalImageRequest::getImageName() const {
return imageName_;
}
void DeleteLocalImageRequest::setImageName(const std::string &imageName) {
imageName_ = imageName;
setParameter(std::string("ImageName"), imageName);
}

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

View File

@@ -1,76 +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/DeleteNodesRequest.h>
using AlibabaCloud::EHPC::Model::DeleteNodesRequest;
DeleteNodesRequest::DeleteNodesRequest()
: RpcServiceRequest("ehpc", "2018-04-12", "DeleteNodes") {
setMethod(HttpRequest::Method::Get);
}
DeleteNodesRequest::~DeleteNodesRequest() {}
std::vector<DeleteNodesRequest::Instance> DeleteNodesRequest::getInstance() const {
return instance_;
}
void DeleteNodesRequest::setInstance(const std::vector<DeleteNodesRequest::Instance> &instance) {
instance_ = instance;
for(int dep1 = 0; dep1 != instance.size(); dep1++) {
auto instanceObj = instance.at(dep1);
std::string instanceObjStr = std::string("Instance") + "." + std::to_string(dep1 + 1);
setParameter(instanceObjStr + ".Id", instanceObj.id);
}
}
std::string DeleteNodesRequest::getClusterId() const {
return clusterId_;
}
void DeleteNodesRequest::setClusterId(const std::string &clusterId) {
clusterId_ = clusterId;
setParameter(std::string("ClusterId"), clusterId);
}
bool DeleteNodesRequest::getSync() const {
return sync_;
}
void DeleteNodesRequest::setSync(bool sync) {
sync_ = sync;
setParameter(std::string("Sync"), sync ? "true" : "false");
}
std::string DeleteNodesRequest::getAccessKeyId() const {
return accessKeyId_;
}
void DeleteNodesRequest::setAccessKeyId(const std::string &accessKeyId) {
accessKeyId_ = accessKeyId;
setParameter(std::string("AccessKeyId"), accessKeyId);
}
bool DeleteNodesRequest::getReleaseInstance() const {
return releaseInstance_;
}
void DeleteNodesRequest::setReleaseInstance(bool releaseInstance) {
releaseInstance_ = releaseInstance;
setParameter(std::string("ReleaseInstance"), releaseInstance ? "true" : "false");
}

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/DeleteNodesResult.h>
#include <json/json.h>
using namespace AlibabaCloud::EHPC;
using namespace AlibabaCloud::EHPC::Model;
DeleteNodesResult::DeleteNodesResult() :
ServiceResult()
{}
DeleteNodesResult::DeleteNodesResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
DeleteNodesResult::~DeleteNodesResult()
{}
void DeleteNodesResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
if(!value["TaskId"].isNull())
taskId_ = value["TaskId"].asString();
}
std::string DeleteNodesResult::getTaskId()const
{
return taskId_;
}

View File

@@ -1,54 +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/DeleteQueueRequest.h>
using AlibabaCloud::EHPC::Model::DeleteQueueRequest;
DeleteQueueRequest::DeleteQueueRequest()
: RpcServiceRequest("ehpc", "2018-04-12", "DeleteQueue") {
setMethod(HttpRequest::Method::Get);
}
DeleteQueueRequest::~DeleteQueueRequest() {}
std::string DeleteQueueRequest::getQueueName() const {
return queueName_;
}
void DeleteQueueRequest::setQueueName(const std::string &queueName) {
queueName_ = queueName;
setParameter(std::string("QueueName"), queueName);
}
std::string DeleteQueueRequest::getClusterId() const {
return clusterId_;
}
void DeleteQueueRequest::setClusterId(const std::string &clusterId) {
clusterId_ = clusterId;
setParameter(std::string("ClusterId"), clusterId);
}
std::string DeleteQueueRequest::getAccessKeyId() const {
return accessKeyId_;
}
void DeleteQueueRequest::setAccessKeyId(const std::string &accessKeyId) {
accessKeyId_ = accessKeyId;
setParameter(std::string("AccessKeyId"), accessKeyId);
}

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

View File

@@ -1,54 +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/DeleteSecurityGroupRequest.h>
using AlibabaCloud::EHPC::Model::DeleteSecurityGroupRequest;
DeleteSecurityGroupRequest::DeleteSecurityGroupRequest()
: RpcServiceRequest("ehpc", "2018-04-12", "DeleteSecurityGroup") {
setMethod(HttpRequest::Method::Get);
}
DeleteSecurityGroupRequest::~DeleteSecurityGroupRequest() {}
std::string DeleteSecurityGroupRequest::getSecurityGroupId() const {
return securityGroupId_;
}
void DeleteSecurityGroupRequest::setSecurityGroupId(const std::string &securityGroupId) {
securityGroupId_ = securityGroupId;
setParameter(std::string("SecurityGroupId"), securityGroupId);
}
std::string DeleteSecurityGroupRequest::getClusterId() const {
return clusterId_;
}
void DeleteSecurityGroupRequest::setClusterId(const std::string &clusterId) {
clusterId_ = clusterId;
setParameter(std::string("ClusterId"), clusterId);
}
std::string DeleteSecurityGroupRequest::getAccessKeyId() const {
return accessKeyId_;
}
void DeleteSecurityGroupRequest::setAccessKeyId(const std::string &accessKeyId) {
accessKeyId_ = accessKeyId;
setParameter(std::string("AccessKeyId"), accessKeyId);
}

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

View File

@@ -1,67 +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/DeleteUsersRequest.h>
using AlibabaCloud::EHPC::Model::DeleteUsersRequest;
DeleteUsersRequest::DeleteUsersRequest()
: RpcServiceRequest("ehpc", "2018-04-12", "DeleteUsers") {
setMethod(HttpRequest::Method::Get);
}
DeleteUsersRequest::~DeleteUsersRequest() {}
std::string DeleteUsersRequest::getClusterId() const {
return clusterId_;
}
void DeleteUsersRequest::setClusterId(const std::string &clusterId) {
clusterId_ = clusterId;
setParameter(std::string("ClusterId"), clusterId);
}
std::string DeleteUsersRequest::getAccessKeyId() const {
return accessKeyId_;
}
void DeleteUsersRequest::setAccessKeyId(const std::string &accessKeyId) {
accessKeyId_ = accessKeyId;
setParameter(std::string("AccessKeyId"), accessKeyId);
}
bool DeleteUsersRequest::getAsync() const {
return async_;
}
void DeleteUsersRequest::setAsync(bool async) {
async_ = async;
setParameter(std::string("Async"), async ? "true" : "false");
}
std::vector<DeleteUsersRequest::User> DeleteUsersRequest::getUser() const {
return user_;
}
void DeleteUsersRequest::setUser(const std::vector<DeleteUsersRequest::User> &user) {
user_ = user;
for(int dep1 = 0; dep1 != user.size(); dep1++) {
auto userObj = user.at(dep1);
std::string userObjStr = std::string("User") + "." + std::to_string(dep1 + 1);
setParameter(userObjStr + ".Name", userObj.name);
}
}

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

View File

@@ -1,45 +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/DescribeAutoScaleConfigRequest.h>
using AlibabaCloud::EHPC::Model::DescribeAutoScaleConfigRequest;
DescribeAutoScaleConfigRequest::DescribeAutoScaleConfigRequest()
: RpcServiceRequest("ehpc", "2018-04-12", "DescribeAutoScaleConfig") {
setMethod(HttpRequest::Method::Get);
}
DescribeAutoScaleConfigRequest::~DescribeAutoScaleConfigRequest() {}
std::string DescribeAutoScaleConfigRequest::getClusterId() const {
return clusterId_;
}
void DescribeAutoScaleConfigRequest::setClusterId(const std::string &clusterId) {
clusterId_ = clusterId;
setParameter(std::string("ClusterId"), clusterId);
}
std::string DescribeAutoScaleConfigRequest::getAccessKeyId() const {
return accessKeyId_;
}
void DescribeAutoScaleConfigRequest::setAccessKeyId(const std::string &accessKeyId) {
accessKeyId_ = accessKeyId;
setParameter(std::string("AccessKeyId"), accessKeyId);
}

View File

@@ -1,149 +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/DescribeAutoScaleConfigResult.h>
#include <json/json.h>
using namespace AlibabaCloud::EHPC;
using namespace AlibabaCloud::EHPC::Model;
DescribeAutoScaleConfigResult::DescribeAutoScaleConfigResult() :
ServiceResult()
{}
DescribeAutoScaleConfigResult::DescribeAutoScaleConfigResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
DescribeAutoScaleConfigResult::~DescribeAutoScaleConfigResult()
{}
void DescribeAutoScaleConfigResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
if(!value["MaxNodesInCluster"].isNull())
maxNodesInCluster_ = std::stoi(value["MaxNodesInCluster"].asString());
if(!value["GrowTimeoutInMinutes"].isNull())
growTimeoutInMinutes_ = std::stoi(value["GrowTimeoutInMinutes"].asString());
if(!value["SpotStrategy"].isNull())
spotStrategy_ = value["SpotStrategy"].asString();
if(!value["EnableAutoShrink"].isNull())
enableAutoShrink_ = value["EnableAutoShrink"].asString() == "true";
if(!value["ClusterType"].isNull())
clusterType_ = value["ClusterType"].asString();
if(!value["EnableAutoGrow"].isNull())
enableAutoGrow_ = value["EnableAutoGrow"].asString() == "true";
if(!value["ExcludeNodes"].isNull())
excludeNodes_ = value["ExcludeNodes"].asString();
if(!value["GrowIntervalInMinutes"].isNull())
growIntervalInMinutes_ = std::stoi(value["GrowIntervalInMinutes"].asString());
if(!value["ShrinkIntervalInMinutes"].isNull())
shrinkIntervalInMinutes_ = std::stoi(value["ShrinkIntervalInMinutes"].asString());
if(!value["SpotPriceLimit"].isNull())
spotPriceLimit_ = value["SpotPriceLimit"].asString();
if(!value["ShrinkIdleTimes"].isNull())
shrinkIdleTimes_ = std::stoi(value["ShrinkIdleTimes"].asString());
if(!value["ExtraNodesGrowRatio"].isNull())
extraNodesGrowRatio_ = std::stoi(value["ExtraNodesGrowRatio"].asString());
if(!value["GrowRatio"].isNull())
growRatio_ = std::stoi(value["GrowRatio"].asString());
if(!value["Uid"].isNull())
uid_ = value["Uid"].asString();
if(!value["ClusterId"].isNull())
clusterId_ = value["ClusterId"].asString();
}
int DescribeAutoScaleConfigResult::getExtraNodesGrowRatio()const
{
return extraNodesGrowRatio_;
}
bool DescribeAutoScaleConfigResult::getEnableAutoGrow()const
{
return enableAutoGrow_;
}
std::string DescribeAutoScaleConfigResult::getClusterId()const
{
return clusterId_;
}
int DescribeAutoScaleConfigResult::getMaxNodesInCluster()const
{
return maxNodesInCluster_;
}
int DescribeAutoScaleConfigResult::getShrinkIdleTimes()const
{
return shrinkIdleTimes_;
}
bool DescribeAutoScaleConfigResult::getEnableAutoShrink()const
{
return enableAutoShrink_;
}
std::string DescribeAutoScaleConfigResult::getClusterType()const
{
return clusterType_;
}
int DescribeAutoScaleConfigResult::getGrowRatio()const
{
return growRatio_;
}
int DescribeAutoScaleConfigResult::getGrowIntervalInMinutes()const
{
return growIntervalInMinutes_;
}
std::string DescribeAutoScaleConfigResult::getUid()const
{
return uid_;
}
int DescribeAutoScaleConfigResult::getGrowTimeoutInMinutes()const
{
return growTimeoutInMinutes_;
}
int DescribeAutoScaleConfigResult::getShrinkIntervalInMinutes()const
{
return shrinkIntervalInMinutes_;
}
std::string DescribeAutoScaleConfigResult::getSpotPriceLimit()const
{
return spotPriceLimit_;
}
std::string DescribeAutoScaleConfigResult::getExcludeNodes()const
{
return excludeNodes_;
}
std::string DescribeAutoScaleConfigResult::getSpotStrategy()const
{
return spotStrategy_;
}

View File

@@ -1,45 +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/DescribeClusterRequest.h>
using AlibabaCloud::EHPC::Model::DescribeClusterRequest;
DescribeClusterRequest::DescribeClusterRequest()
: RpcServiceRequest("ehpc", "2018-04-12", "DescribeCluster") {
setMethod(HttpRequest::Method::Get);
}
DescribeClusterRequest::~DescribeClusterRequest() {}
std::string DescribeClusterRequest::getClusterId() const {
return clusterId_;
}
void DescribeClusterRequest::setClusterId(const std::string &clusterId) {
clusterId_ = clusterId;
setParameter(std::string("ClusterId"), clusterId);
}
std::string DescribeClusterRequest::getAccessKeyId() const {
return accessKeyId_;
}
void DescribeClusterRequest::setAccessKeyId(const std::string &accessKeyId) {
accessKeyId_ = accessKeyId;
setParameter(std::string("AccessKeyId"), accessKeyId);
}

View File

@@ -1,238 +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/DescribeClusterResult.h>
#include <json/json.h>
using namespace AlibabaCloud::EHPC;
using namespace AlibabaCloud::EHPC::Model;
DescribeClusterResult::DescribeClusterResult() :
ServiceResult()
{}
DescribeClusterResult::DescribeClusterResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
DescribeClusterResult::~DescribeClusterResult()
{}
void DescribeClusterResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
auto clusterInfoNode = value["ClusterInfo"];
if(!clusterInfoNode["Status"].isNull())
clusterInfo_.status = clusterInfoNode["Status"].asString();
if(!clusterInfoNode["VpcId"].isNull())
clusterInfo_.vpcId = clusterInfoNode["VpcId"].asString();
if(!clusterInfoNode["KeyPairName"].isNull())
clusterInfo_.keyPairName = clusterInfoNode["KeyPairName"].asString();
if(!clusterInfoNode["EcsChargeType"].isNull())
clusterInfo_.ecsChargeType = clusterInfoNode["EcsChargeType"].asString();
if(!clusterInfoNode["SecurityGroupId"].isNull())
clusterInfo_.securityGroupId = clusterInfoNode["SecurityGroupId"].asString();
if(!clusterInfoNode["SccClusterId"].isNull())
clusterInfo_.sccClusterId = clusterInfoNode["SccClusterId"].asString();
if(!clusterInfoNode["CreateTime"].isNull())
clusterInfo_.createTime = clusterInfoNode["CreateTime"].asString();
if(!clusterInfoNode["AccountType"].isNull())
clusterInfo_.accountType = clusterInfoNode["AccountType"].asString();
if(!clusterInfoNode["VolumeProtocol"].isNull())
clusterInfo_.volumeProtocol = clusterInfoNode["VolumeProtocol"].asString();
if(!clusterInfoNode["Description"].isNull())
clusterInfo_.description = clusterInfoNode["Description"].asString();
if(!clusterInfoNode["VolumeId"].isNull())
clusterInfo_.volumeId = clusterInfoNode["VolumeId"].asString();
if(!clusterInfoNode["HaEnable"].isNull())
clusterInfo_.haEnable = clusterInfoNode["HaEnable"].asString() == "true";
if(!clusterInfoNode["BaseOsTag"].isNull())
clusterInfo_.baseOsTag = clusterInfoNode["BaseOsTag"].asString();
if(!clusterInfoNode["Name"].isNull())
clusterInfo_.name = clusterInfoNode["Name"].asString();
if(!clusterInfoNode["ImageId"].isNull())
clusterInfo_.imageId = clusterInfoNode["ImageId"].asString();
if(!clusterInfoNode["SchedulerType"].isNull())
clusterInfo_.schedulerType = clusterInfoNode["SchedulerType"].asString();
if(!clusterInfoNode["SchedulerVersion"].isNull())
clusterInfo_.schedulerVersion = clusterInfoNode["SchedulerVersion"].asString();
if(!clusterInfoNode["DeployMode"].isNull())
clusterInfo_.deployMode = clusterInfoNode["DeployMode"].asString();
if(!clusterInfoNode["ImageOwnerAlias"].isNull())
clusterInfo_.imageOwnerAlias = clusterInfoNode["ImageOwnerAlias"].asString();
if(!clusterInfoNode["OsTag"].isNull())
clusterInfo_.osTag = clusterInfoNode["OsTag"].asString();
if(!clusterInfoNode["VolumeMountpoint"].isNull())
clusterInfo_.volumeMountpoint = clusterInfoNode["VolumeMountpoint"].asString();
if(!clusterInfoNode["RemoteDirectory"].isNull())
clusterInfo_.remoteDirectory = clusterInfoNode["RemoteDirectory"].asString();
if(!clusterInfoNode["RegionId"].isNull())
clusterInfo_.regionId = clusterInfoNode["RegionId"].asString();
if(!clusterInfoNode["VSwitchId"].isNull())
clusterInfo_.vSwitchId = clusterInfoNode["VSwitchId"].asString();
if(!clusterInfoNode["ImageName"].isNull())
clusterInfo_.imageName = clusterInfoNode["ImageName"].asString();
if(!clusterInfoNode["VolumeType"].isNull())
clusterInfo_.volumeType = clusterInfoNode["VolumeType"].asString();
if(!clusterInfoNode["Location"].isNull())
clusterInfo_.location = clusterInfoNode["Location"].asString();
if(!clusterInfoNode["Id"].isNull())
clusterInfo_.id = clusterInfoNode["Id"].asString();
if(!clusterInfoNode["ClientVersion"].isNull())
clusterInfo_.clientVersion = clusterInfoNode["ClientVersion"].asString();
if(!clusterInfoNode["ZoneId"].isNull())
clusterInfo_.zoneId = clusterInfoNode["ZoneId"].asString();
if(!clusterInfoNode["ResourceGroupId"].isNull())
clusterInfo_.resourceGroupId = clusterInfoNode["ResourceGroupId"].asString();
if(!clusterInfoNode["RamRoleName"].isNull())
clusterInfo_.ramRoleName = clusterInfoNode["RamRoleName"].asString();
if(!clusterInfoNode["RamNodeTypes"].isNull())
clusterInfo_.ramNodeTypes = clusterInfoNode["RamNodeTypes"].asString();
if(!clusterInfoNode["ClusterVersion"].isNull())
clusterInfo_.clusterVersion = clusterInfoNode["ClusterVersion"].asString();
if(!clusterInfoNode["WithoutAgent"].isNull())
clusterInfo_.withoutAgent = std::stoi(clusterInfoNode["WithoutAgent"].asString());
if(!clusterInfoNode["Plugin"].isNull())
clusterInfo_.plugin = clusterInfoNode["Plugin"].asString();
if(!clusterInfoNode["SchedulerPreInstall"].isNull())
clusterInfo_.schedulerPreInstall = std::stoi(clusterInfoNode["SchedulerPreInstall"].asString());
if(!clusterInfoNode["Domain"].isNull())
clusterInfo_.domain = clusterInfoNode["Domain"].asString();
if(!clusterInfoNode["OpenldapPar"].isNull())
clusterInfo_.openldapPar = clusterInfoNode["OpenldapPar"].asString();
if(!clusterInfoNode["WinAdPar"].isNull())
clusterInfo_.winAdPar = clusterInfoNode["WinAdPar"].asString();
if(!clusterInfoNode["Period"].isNull())
clusterInfo_.period = clusterInfoNode["Period"].asString();
if(!clusterInfoNode["PeriodUnit"].isNull())
clusterInfo_.periodUnit = clusterInfoNode["PeriodUnit"].asString();
if(!clusterInfoNode["AutoRenewPeriod"].isNull())
clusterInfo_.autoRenewPeriod = clusterInfoNode["AutoRenewPeriod"].asString();
if(!clusterInfoNode["AutoRenew"].isNull())
clusterInfo_.autoRenew = clusterInfoNode["AutoRenew"].asString();
if(!clusterInfoNode["ComputeSpotStrategy"].isNull())
clusterInfo_.computeSpotStrategy = clusterInfoNode["ComputeSpotStrategy"].asString();
if(!clusterInfoNode["ComputeSpotPriceLimit"].isNull())
clusterInfo_.computeSpotPriceLimit = clusterInfoNode["ComputeSpotPriceLimit"].asString();
auto allApplicationsNode = clusterInfoNode["Applications"]["ApplicationInfo"];
for (auto clusterInfoNodeApplicationsApplicationInfo : allApplicationsNode)
{
ClusterInfo::ApplicationInfo applicationInfoObject;
if(!clusterInfoNodeApplicationsApplicationInfo["Tag"].isNull())
applicationInfoObject.tag = clusterInfoNodeApplicationsApplicationInfo["Tag"].asString();
if(!clusterInfoNodeApplicationsApplicationInfo["Name"].isNull())
applicationInfoObject.name = clusterInfoNodeApplicationsApplicationInfo["Name"].asString();
if(!clusterInfoNodeApplicationsApplicationInfo["Version"].isNull())
applicationInfoObject.version = clusterInfoNodeApplicationsApplicationInfo["Version"].asString();
clusterInfo_.applications.push_back(applicationInfoObject);
}
auto allPostInstallScriptsNode = clusterInfoNode["PostInstallScripts"]["PostInstallScriptInfo"];
for (auto clusterInfoNodePostInstallScriptsPostInstallScriptInfo : allPostInstallScriptsNode)
{
ClusterInfo::PostInstallScriptInfo postInstallScriptInfoObject;
if(!clusterInfoNodePostInstallScriptsPostInstallScriptInfo["Url"].isNull())
postInstallScriptInfoObject.url = clusterInfoNodePostInstallScriptsPostInstallScriptInfo["Url"].asString();
if(!clusterInfoNodePostInstallScriptsPostInstallScriptInfo["Args"].isNull())
postInstallScriptInfoObject.args = clusterInfoNodePostInstallScriptsPostInstallScriptInfo["Args"].asString();
clusterInfo_.postInstallScripts.push_back(postInstallScriptInfoObject);
}
auto allOnPremiseInfoNode = clusterInfoNode["OnPremiseInfo"]["OnPremiseInfoItem"];
for (auto clusterInfoNodeOnPremiseInfoOnPremiseInfoItem : allOnPremiseInfoNode)
{
ClusterInfo::OnPremiseInfoItem onPremiseInfoItemObject;
if(!clusterInfoNodeOnPremiseInfoOnPremiseInfoItem["Type"].isNull())
onPremiseInfoItemObject.type = clusterInfoNodeOnPremiseInfoOnPremiseInfoItem["Type"].asString();
if(!clusterInfoNodeOnPremiseInfoOnPremiseInfoItem["HostName"].isNull())
onPremiseInfoItemObject.hostName = clusterInfoNodeOnPremiseInfoOnPremiseInfoItem["HostName"].asString();
if(!clusterInfoNodeOnPremiseInfoOnPremiseInfoItem["IP"].isNull())
onPremiseInfoItemObject.iP = clusterInfoNodeOnPremiseInfoOnPremiseInfoItem["IP"].asString();
clusterInfo_.onPremiseInfo.push_back(onPremiseInfoItemObject);
}
auto allAddOnsInfoNode = clusterInfoNode["AddOnsInfo"]["AddOnsInfoItem"];
for (auto clusterInfoNodeAddOnsInfoAddOnsInfoItem : allAddOnsInfoNode)
{
ClusterInfo::AddOnsInfoItem addOnsInfoItemObject;
if(!clusterInfoNodeAddOnsInfoAddOnsInfoItem["SoftwareId"].isNull())
addOnsInfoItemObject.softwareId = clusterInfoNodeAddOnsInfoAddOnsInfoItem["SoftwareId"].asString();
if(!clusterInfoNodeAddOnsInfoAddOnsInfoItem["DeployMode"].isNull())
addOnsInfoItemObject.deployMode = clusterInfoNodeAddOnsInfoAddOnsInfoItem["DeployMode"].asString();
if(!clusterInfoNodeAddOnsInfoAddOnsInfoItem["Port"].isNull())
addOnsInfoItemObject.port = std::stoi(clusterInfoNodeAddOnsInfoAddOnsInfoItem["Port"].asString());
if(!clusterInfoNodeAddOnsInfoAddOnsInfoItem["Status"].isNull())
addOnsInfoItemObject.status = clusterInfoNodeAddOnsInfoAddOnsInfoItem["Status"].asString();
if(!clusterInfoNodeAddOnsInfoAddOnsInfoItem["URL"].isNull())
addOnsInfoItemObject.uRL = clusterInfoNodeAddOnsInfoAddOnsInfoItem["URL"].asString();
clusterInfo_.addOnsInfo.push_back(addOnsInfoItemObject);
}
auto allNodesNode = clusterInfoNode["Nodes"]["NodesInfo"];
for (auto clusterInfoNodeNodesNodesInfo : allNodesNode)
{
ClusterInfo::NodesInfo nodesInfoObject;
if(!clusterInfoNodeNodesNodesInfo["Role"].isNull())
nodesInfoObject.role = clusterInfoNodeNodesNodesInfo["Role"].asString();
if(!clusterInfoNodeNodesNodesInfo["HostName"].isNull())
nodesInfoObject.hostName = clusterInfoNodeNodesNodesInfo["HostName"].asString();
if(!clusterInfoNodeNodesNodesInfo["IpAddress"].isNull())
nodesInfoObject.ipAddress = clusterInfoNodeNodesNodesInfo["IpAddress"].asString();
if(!clusterInfoNodeNodesNodesInfo["AccountType"].isNull())
nodesInfoObject.accountType = clusterInfoNodeNodesNodesInfo["AccountType"].asString();
if(!clusterInfoNodeNodesNodesInfo["Dir"].isNull())
nodesInfoObject.dir = clusterInfoNodeNodesNodesInfo["Dir"].asString();
if(!clusterInfoNodeNodesNodesInfo["SchedulerType"].isNull())
nodesInfoObject.schedulerType = clusterInfoNodeNodesNodesInfo["SchedulerType"].asString();
clusterInfo_.nodes.push_back(nodesInfoObject);
}
auto ecsInfoNode = clusterInfoNode["EcsInfo"];
auto managerNode = ecsInfoNode["Manager"];
if(!managerNode["InstanceType"].isNull())
clusterInfo_.ecsInfo.manager.instanceType = managerNode["InstanceType"].asString();
if(!managerNode["Count"].isNull())
clusterInfo_.ecsInfo.manager.count = std::stoi(managerNode["Count"].asString());
auto computeNode = ecsInfoNode["Compute"];
if(!computeNode["InstanceType"].isNull())
clusterInfo_.ecsInfo.compute.instanceType = computeNode["InstanceType"].asString();
if(!computeNode["Count"].isNull())
clusterInfo_.ecsInfo.compute.count = std::stoi(computeNode["Count"].asString());
auto loginNode = ecsInfoNode["Login"];
if(!loginNode["InstanceType"].isNull())
clusterInfo_.ecsInfo.login.instanceType = loginNode["InstanceType"].asString();
if(!loginNode["Count"].isNull())
clusterInfo_.ecsInfo.login.count = std::stoi(loginNode["Count"].asString());
auto proxyMgrNode = ecsInfoNode["ProxyMgr"];
if(!proxyMgrNode["InstanceType"].isNull())
clusterInfo_.ecsInfo.proxyMgr.instanceType = proxyMgrNode["InstanceType"].asString();
if(!proxyMgrNode["Count"].isNull())
clusterInfo_.ecsInfo.proxyMgr.count = std::stoi(proxyMgrNode["Count"].asString());
auto initialImageNode = clusterInfoNode["InitialImage"];
if(!initialImageNode["OsTag"].isNull())
clusterInfo_.initialImage.osTag = initialImageNode["OsTag"].asString();
if(!initialImageNode["ImageOwnerAlias"].isNull())
clusterInfo_.initialImage.imageOwnerAlias = initialImageNode["ImageOwnerAlias"].asString();
if(!initialImageNode["ImageId"].isNull())
clusterInfo_.initialImage.imageId = initialImageNode["ImageId"].asString();
}
DescribeClusterResult::ClusterInfo DescribeClusterResult::getClusterInfo()const
{
return clusterInfo_;
}

View File

@@ -1,45 +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/DescribeContainerAppRequest.h>
using AlibabaCloud::EHPC::Model::DescribeContainerAppRequest;
DescribeContainerAppRequest::DescribeContainerAppRequest()
: RpcServiceRequest("ehpc", "2018-04-12", "DescribeContainerApp") {
setMethod(HttpRequest::Method::Get);
}
DescribeContainerAppRequest::~DescribeContainerAppRequest() {}
std::string DescribeContainerAppRequest::getAccessKeyId() const {
return accessKeyId_;
}
void DescribeContainerAppRequest::setAccessKeyId(const std::string &accessKeyId) {
accessKeyId_ = accessKeyId;
setParameter(std::string("AccessKeyId"), accessKeyId);
}
std::string DescribeContainerAppRequest::getContainerId() const {
return containerId_;
}
void DescribeContainerAppRequest::setContainerId(const std::string &containerId) {
containerId_ = containerId;
setParameter(std::string("ContainerId"), containerId);
}

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/DescribeContainerAppResult.h>
#include <json/json.h>
using namespace AlibabaCloud::EHPC;
using namespace AlibabaCloud::EHPC::Model;
DescribeContainerAppResult::DescribeContainerAppResult() :
ServiceResult()
{}
DescribeContainerAppResult::DescribeContainerAppResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
DescribeContainerAppResult::~DescribeContainerAppResult()
{}
void DescribeContainerAppResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
auto containerAppInfoNode = value["ContainerAppInfo"];
if(!containerAppInfoNode["Type"].isNull())
containerAppInfo_.type = containerAppInfoNode["Type"].asString();
if(!containerAppInfoNode["Description"].isNull())
containerAppInfo_.description = containerAppInfoNode["Description"].asString();
if(!containerAppInfoNode["CreateTime"].isNull())
containerAppInfo_.createTime = containerAppInfoNode["CreateTime"].asString();
if(!containerAppInfoNode["Repository"].isNull())
containerAppInfo_.repository = containerAppInfoNode["Repository"].asString();
if(!containerAppInfoNode["ImageTag"].isNull())
containerAppInfo_.imageTag = containerAppInfoNode["ImageTag"].asString();
if(!containerAppInfoNode["Name"].isNull())
containerAppInfo_.name = containerAppInfoNode["Name"].asString();
if(!containerAppInfoNode["Id"].isNull())
containerAppInfo_.id = containerAppInfoNode["Id"].asString();
}
DescribeContainerAppResult::ContainerAppInfo DescribeContainerAppResult::getContainerAppInfo()const
{
return containerAppInfo_;
}

View File

@@ -1,54 +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/DescribeEstackImageRequest.h>
using AlibabaCloud::EHPC::Model::DescribeEstackImageRequest;
DescribeEstackImageRequest::DescribeEstackImageRequest()
: RpcServiceRequest("ehpc", "2018-04-12", "DescribeEstackImage") {
setMethod(HttpRequest::Method::Get);
}
DescribeEstackImageRequest::~DescribeEstackImageRequest() {}
int DescribeEstackImageRequest::getPageNumber() const {
return pageNumber_;
}
void DescribeEstackImageRequest::setPageNumber(int pageNumber) {
pageNumber_ = pageNumber;
setParameter(std::string("PageNumber"), std::to_string(pageNumber));
}
std::string DescribeEstackImageRequest::getAccessKeyId() const {
return accessKeyId_;
}
void DescribeEstackImageRequest::setAccessKeyId(const std::string &accessKeyId) {
accessKeyId_ = accessKeyId;
setParameter(std::string("AccessKeyId"), accessKeyId);
}
int DescribeEstackImageRequest::getPageSize() const {
return pageSize_;
}
void DescribeEstackImageRequest::setPageSize(int pageSize) {
pageSize_ = pageSize;
setParameter(std::string("PageSize"), std::to_string(pageSize));
}

View File

@@ -1,86 +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/DescribeEstackImageResult.h>
#include <json/json.h>
using namespace AlibabaCloud::EHPC;
using namespace AlibabaCloud::EHPC::Model;
DescribeEstackImageResult::DescribeEstackImageResult() :
ServiceResult()
{}
DescribeEstackImageResult::DescribeEstackImageResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
DescribeEstackImageResult::~DescribeEstackImageResult()
{}
void DescribeEstackImageResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
auto allImageListNode = value["ImageList"]["ImageListInfo"];
for (auto valueImageListImageListInfo : allImageListNode)
{
ImageListInfo imageListObject;
if(!valueImageListImageListInfo["ImageName"].isNull())
imageListObject.imageName = valueImageListImageListInfo["ImageName"].asString();
if(!valueImageListImageListInfo["ImageSize"].isNull())
imageListObject.imageSize = std::stoi(valueImageListImageListInfo["ImageSize"].asString());
if(!valueImageListImageListInfo["RecentUpdateTime"].isNull())
imageListObject.recentUpdateTime = valueImageListImageListInfo["RecentUpdateTime"].asString();
if(!valueImageListImageListInfo["ImageUrl"].isNull())
imageListObject.imageUrl = valueImageListImageListInfo["ImageUrl"].asString();
if(!valueImageListImageListInfo["ImageType"].isNull())
imageListObject.imageType = valueImageListImageListInfo["ImageType"].asString();
imageList_.push_back(imageListObject);
}
if(!value["PageSize"].isNull())
pageSize_ = std::stoi(value["PageSize"].asString());
if(!value["PageNumber"].isNull())
pageNumber_ = std::stoi(value["PageNumber"].asString());
if(!value["TotalCount"].isNull())
totalCount_ = std::stoi(value["TotalCount"].asString());
}
int DescribeEstackImageResult::getTotalCount()const
{
return totalCount_;
}
int DescribeEstackImageResult::getPageSize()const
{
return pageSize_;
}
int DescribeEstackImageResult::getPageNumber()const
{
return pageNumber_;
}
std::vector<DescribeEstackImageResult::ImageListInfo> DescribeEstackImageResult::getImageList()const
{
return imageList_;
}

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.
*/
#include <alibabacloud/ehpc/model/DescribeGWSClusterPolicyRequest.h>
using AlibabaCloud::EHPC::Model::DescribeGWSClusterPolicyRequest;
DescribeGWSClusterPolicyRequest::DescribeGWSClusterPolicyRequest()
: RpcServiceRequest("ehpc", "2018-04-12", "DescribeGWSClusterPolicy") {
setMethod(HttpRequest::Method::Post);
}
DescribeGWSClusterPolicyRequest::~DescribeGWSClusterPolicyRequest() {}
std::string DescribeGWSClusterPolicyRequest::getClusterId() const {
return clusterId_;
}
void DescribeGWSClusterPolicyRequest::setClusterId(const std::string &clusterId) {
clusterId_ = clusterId;
setParameter(std::string("ClusterId"), clusterId);
}
std::string DescribeGWSClusterPolicyRequest::getAccessKeyId() const {
return accessKeyId_;
}
void DescribeGWSClusterPolicyRequest::setAccessKeyId(const std::string &accessKeyId) {
accessKeyId_ = accessKeyId;
setParameter(std::string("AccessKeyId"), accessKeyId);
}
bool DescribeGWSClusterPolicyRequest::getAsyncMode() const {
return asyncMode_;
}
void DescribeGWSClusterPolicyRequest::setAsyncMode(bool asyncMode) {
asyncMode_ = asyncMode;
setParameter(std::string("AsyncMode"), asyncMode ? "true" : "false");
}
std::string DescribeGWSClusterPolicyRequest::getTaskId() const {
return taskId_;
}
void DescribeGWSClusterPolicyRequest::setTaskId(const std::string &taskId) {
taskId_ = taskId;
setParameter(std::string("TaskId"), taskId);
}

View File

@@ -1,72 +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/DescribeGWSClusterPolicyResult.h>
#include <json/json.h>
using namespace AlibabaCloud::EHPC;
using namespace AlibabaCloud::EHPC::Model;
DescribeGWSClusterPolicyResult::DescribeGWSClusterPolicyResult() :
ServiceResult()
{}
DescribeGWSClusterPolicyResult::DescribeGWSClusterPolicyResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
DescribeGWSClusterPolicyResult::~DescribeGWSClusterPolicyResult()
{}
void DescribeGWSClusterPolicyResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
if(!value["Watermark"].isNull())
watermark_ = value["Watermark"].asString();
if(!value["Clipboard"].isNull())
clipboard_ = value["Clipboard"].asString();
if(!value["UsbRedirect"].isNull())
usbRedirect_ = value["UsbRedirect"].asString();
if(!value["LocalDrive"].isNull())
localDrive_ = value["LocalDrive"].asString();
}
std::string DescribeGWSClusterPolicyResult::getLocalDrive()const
{
return localDrive_;
}
std::string DescribeGWSClusterPolicyResult::getUsbRedirect()const
{
return usbRedirect_;
}
std::string DescribeGWSClusterPolicyResult::getClipboard()const
{
return clipboard_;
}
std::string DescribeGWSClusterPolicyResult::getWatermark()const
{
return watermark_;
}

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.
*/
#include <alibabacloud/ehpc/model/DescribeGWSClustersRequest.h>
using AlibabaCloud::EHPC::Model::DescribeGWSClustersRequest;
DescribeGWSClustersRequest::DescribeGWSClustersRequest()
: RpcServiceRequest("ehpc", "2018-04-12", "DescribeGWSClusters") {
setMethod(HttpRequest::Method::Get);
}
DescribeGWSClustersRequest::~DescribeGWSClustersRequest() {}
std::string DescribeGWSClustersRequest::getClusterId() const {
return clusterId_;
}
void DescribeGWSClustersRequest::setClusterId(const std::string &clusterId) {
clusterId_ = clusterId;
setParameter(std::string("ClusterId"), clusterId);
}
int DescribeGWSClustersRequest::getPageNumber() const {
return pageNumber_;
}
void DescribeGWSClustersRequest::setPageNumber(int pageNumber) {
pageNumber_ = pageNumber;
setParameter(std::string("PageNumber"), std::to_string(pageNumber));
}
std::string DescribeGWSClustersRequest::getAccessKeyId() const {
return accessKeyId_;
}
void DescribeGWSClustersRequest::setAccessKeyId(const std::string &accessKeyId) {
accessKeyId_ = accessKeyId;
setParameter(std::string("AccessKeyId"), accessKeyId);
}
int DescribeGWSClustersRequest::getPageSize() const {
return pageSize_;
}
void DescribeGWSClustersRequest::setPageSize(int pageSize) {
pageSize_ = pageSize;
setParameter(std::string("PageSize"), std::to_string(pageSize));
}

View File

@@ -1,93 +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/DescribeGWSClustersResult.h>
#include <json/json.h>
using namespace AlibabaCloud::EHPC;
using namespace AlibabaCloud::EHPC::Model;
DescribeGWSClustersResult::DescribeGWSClustersResult() :
ServiceResult()
{}
DescribeGWSClustersResult::DescribeGWSClustersResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
DescribeGWSClustersResult::~DescribeGWSClustersResult()
{}
void DescribeGWSClustersResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
auto allClustersNode = value["Clusters"]["ClusterInfo"];
for (auto valueClustersClusterInfo : allClustersNode)
{
ClusterInfo clustersObject;
if(!valueClustersClusterInfo["VpcId"].isNull())
clustersObject.vpcId = valueClustersClusterInfo["VpcId"].asString();
if(!valueClustersClusterInfo["Status"].isNull())
clustersObject.status = valueClustersClusterInfo["Status"].asString();
if(!valueClustersClusterInfo["InstanceCount"].isNull())
clustersObject.instanceCount = std::stoi(valueClustersClusterInfo["InstanceCount"].asString());
if(!valueClustersClusterInfo["CreateTime"].isNull())
clustersObject.createTime = valueClustersClusterInfo["CreateTime"].asString();
if(!valueClustersClusterInfo["ClusterId"].isNull())
clustersObject.clusterId = valueClustersClusterInfo["ClusterId"].asString();
clusters_.push_back(clustersObject);
}
if(!value["PageSize"].isNull())
pageSize_ = std::stoi(value["PageSize"].asString());
if(!value["PageNumber"].isNull())
pageNumber_ = std::stoi(value["PageNumber"].asString());
if(!value["CallerType"].isNull())
callerType_ = value["CallerType"].asString();
if(!value["TotalCount"].isNull())
totalCount_ = std::stoi(value["TotalCount"].asString());
}
int DescribeGWSClustersResult::getTotalCount()const
{
return totalCount_;
}
int DescribeGWSClustersResult::getPageSize()const
{
return pageSize_;
}
int DescribeGWSClustersResult::getPageNumber()const
{
return pageNumber_;
}
std::vector<DescribeGWSClustersResult::ClusterInfo> DescribeGWSClustersResult::getClusters()const
{
return clusters_;
}
std::string DescribeGWSClustersResult::getCallerType()const
{
return callerType_;
}

View File

@@ -1,54 +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/DescribeGWSImagesRequest.h>
using AlibabaCloud::EHPC::Model::DescribeGWSImagesRequest;
DescribeGWSImagesRequest::DescribeGWSImagesRequest()
: RpcServiceRequest("ehpc", "2018-04-12", "DescribeGWSImages") {
setMethod(HttpRequest::Method::Get);
}
DescribeGWSImagesRequest::~DescribeGWSImagesRequest() {}
int DescribeGWSImagesRequest::getPageNumber() const {
return pageNumber_;
}
void DescribeGWSImagesRequest::setPageNumber(int pageNumber) {
pageNumber_ = pageNumber;
setParameter(std::string("PageNumber"), std::to_string(pageNumber));
}
std::string DescribeGWSImagesRequest::getAccessKeyId() const {
return accessKeyId_;
}
void DescribeGWSImagesRequest::setAccessKeyId(const std::string &accessKeyId) {
accessKeyId_ = accessKeyId;
setParameter(std::string("AccessKeyId"), accessKeyId);
}
int DescribeGWSImagesRequest::getPageSize() const {
return pageSize_;
}
void DescribeGWSImagesRequest::setPageSize(int pageSize) {
pageSize_ = pageSize;
setParameter(std::string("PageSize"), std::to_string(pageSize));
}

View File

@@ -1,90 +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/DescribeGWSImagesResult.h>
#include <json/json.h>
using namespace AlibabaCloud::EHPC;
using namespace AlibabaCloud::EHPC::Model;
DescribeGWSImagesResult::DescribeGWSImagesResult() :
ServiceResult()
{}
DescribeGWSImagesResult::DescribeGWSImagesResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
DescribeGWSImagesResult::~DescribeGWSImagesResult()
{}
void DescribeGWSImagesResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
auto allImagesNode = value["Images"]["ImageInfo"];
for (auto valueImagesImageInfo : allImagesNode)
{
ImageInfo imagesObject;
if(!valueImagesImageInfo["Status"].isNull())
imagesObject.status = valueImagesImageInfo["Status"].asString();
if(!valueImagesImageInfo["ImageType"].isNull())
imagesObject.imageType = valueImagesImageInfo["ImageType"].asString();
if(!valueImagesImageInfo["Progress"].isNull())
imagesObject.progress = valueImagesImageInfo["Progress"].asString();
if(!valueImagesImageInfo["Size"].isNull())
imagesObject.size = std::stoi(valueImagesImageInfo["Size"].asString());
if(!valueImagesImageInfo["CreateTime"].isNull())
imagesObject.createTime = valueImagesImageInfo["CreateTime"].asString();
if(!valueImagesImageInfo["Name"].isNull())
imagesObject.name = valueImagesImageInfo["Name"].asString();
if(!valueImagesImageInfo["ImageId"].isNull())
imagesObject.imageId = valueImagesImageInfo["ImageId"].asString();
images_.push_back(imagesObject);
}
if(!value["PageSize"].isNull())
pageSize_ = std::stoi(value["PageSize"].asString());
if(!value["PageNumber"].isNull())
pageNumber_ = std::stoi(value["PageNumber"].asString());
if(!value["TotalCount"].isNull())
totalCount_ = std::stoi(value["TotalCount"].asString());
}
int DescribeGWSImagesResult::getTotalCount()const
{
return totalCount_;
}
int DescribeGWSImagesResult::getPageSize()const
{
return pageSize_;
}
int DescribeGWSImagesResult::getPageNumber()const
{
return pageNumber_;
}
std::vector<DescribeGWSImagesResult::ImageInfo> DescribeGWSImagesResult::getImages()const
{
return images_;
}

View File

@@ -1,90 +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/DescribeGWSInstancesRequest.h>
using AlibabaCloud::EHPC::Model::DescribeGWSInstancesRequest;
DescribeGWSInstancesRequest::DescribeGWSInstancesRequest()
: RpcServiceRequest("ehpc", "2018-04-12", "DescribeGWSInstances") {
setMethod(HttpRequest::Method::Get);
}
DescribeGWSInstancesRequest::~DescribeGWSInstancesRequest() {}
std::string DescribeGWSInstancesRequest::getClusterId() const {
return clusterId_;
}
void DescribeGWSInstancesRequest::setClusterId(const std::string &clusterId) {
clusterId_ = clusterId;
setParameter(std::string("ClusterId"), clusterId);
}
int DescribeGWSInstancesRequest::getPageNumber() const {
return pageNumber_;
}
void DescribeGWSInstancesRequest::setPageNumber(int pageNumber) {
pageNumber_ = pageNumber;
setParameter(std::string("PageNumber"), std::to_string(pageNumber));
}
std::string DescribeGWSInstancesRequest::getAccessKeyId() const {
return accessKeyId_;
}
void DescribeGWSInstancesRequest::setAccessKeyId(const std::string &accessKeyId) {
accessKeyId_ = accessKeyId;
setParameter(std::string("AccessKeyId"), accessKeyId);
}
std::string DescribeGWSInstancesRequest::getInstanceId() const {
return instanceId_;
}
void DescribeGWSInstancesRequest::setInstanceId(const std::string &instanceId) {
instanceId_ = instanceId;
setParameter(std::string("InstanceId"), instanceId);
}
int DescribeGWSInstancesRequest::getPageSize() const {
return pageSize_;
}
void DescribeGWSInstancesRequest::setPageSize(int pageSize) {
pageSize_ = pageSize;
setParameter(std::string("PageSize"), std::to_string(pageSize));
}
long DescribeGWSInstancesRequest::getUserUid() const {
return userUid_;
}
void DescribeGWSInstancesRequest::setUserUid(long userUid) {
userUid_ = userUid;
setParameter(std::string("UserUid"), std::to_string(userUid));
}
std::string DescribeGWSInstancesRequest::getUserName() const {
return userName_;
}
void DescribeGWSInstancesRequest::setUserName(const std::string &userName) {
userName_ = userName;
setParameter(std::string("UserName"), userName);
}

View File

@@ -1,106 +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/DescribeGWSInstancesResult.h>
#include <json/json.h>
using namespace AlibabaCloud::EHPC;
using namespace AlibabaCloud::EHPC::Model;
DescribeGWSInstancesResult::DescribeGWSInstancesResult() :
ServiceResult()
{}
DescribeGWSInstancesResult::DescribeGWSInstancesResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
DescribeGWSInstancesResult::~DescribeGWSInstancesResult()
{}
void DescribeGWSInstancesResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
auto allInstancesNode = value["Instances"]["InstanceInfo"];
for (auto valueInstancesInstanceInfo : allInstancesNode)
{
InstanceInfo instancesObject;
if(!valueInstancesInstanceInfo["Status"].isNull())
instancesObject.status = valueInstancesInstanceInfo["Status"].asString();
if(!valueInstancesInstanceInfo["WorkMode"].isNull())
instancesObject.workMode = valueInstancesInstanceInfo["WorkMode"].asString();
if(!valueInstancesInstanceInfo["ExpireTime"].isNull())
instancesObject.expireTime = valueInstancesInstanceInfo["ExpireTime"].asString();
if(!valueInstancesInstanceInfo["CreateTime"].isNull())
instancesObject.createTime = valueInstancesInstanceInfo["CreateTime"].asString();
if(!valueInstancesInstanceInfo["InstanceId"].isNull())
instancesObject.instanceId = valueInstancesInstanceInfo["InstanceId"].asString();
if(!valueInstancesInstanceInfo["Name"].isNull())
instancesObject.name = valueInstancesInstanceInfo["Name"].asString();
if(!valueInstancesInstanceInfo["InstanceType"].isNull())
instancesObject.instanceType = valueInstancesInstanceInfo["InstanceType"].asString();
if(!valueInstancesInstanceInfo["UserName"].isNull())
instancesObject.userName = valueInstancesInstanceInfo["UserName"].asString();
if(!valueInstancesInstanceInfo["ClusterId"].isNull())
instancesObject.clusterId = valueInstancesInstanceInfo["ClusterId"].asString();
auto allAppListNode = valueInstancesInstanceInfo["AppList"]["AppInfo"];
for (auto valueInstancesInstanceInfoAppListAppInfo : allAppListNode)
{
InstanceInfo::AppInfo appListObject;
if(!valueInstancesInstanceInfoAppListAppInfo["AppName"].isNull())
appListObject.appName = valueInstancesInstanceInfoAppListAppInfo["AppName"].asString();
if(!valueInstancesInstanceInfoAppListAppInfo["AppArgs"].isNull())
appListObject.appArgs = valueInstancesInstanceInfoAppListAppInfo["AppArgs"].asString();
if(!valueInstancesInstanceInfoAppListAppInfo["AppPath"].isNull())
appListObject.appPath = valueInstancesInstanceInfoAppListAppInfo["AppPath"].asString();
instancesObject.appList.push_back(appListObject);
}
instances_.push_back(instancesObject);
}
if(!value["PageSize"].isNull())
pageSize_ = std::stoi(value["PageSize"].asString());
if(!value["PageNumber"].isNull())
pageNumber_ = std::stoi(value["PageNumber"].asString());
if(!value["TotalCount"].isNull())
totalCount_ = std::stoi(value["TotalCount"].asString());
}
std::vector<DescribeGWSInstancesResult::InstanceInfo> DescribeGWSInstancesResult::getInstances()const
{
return instances_;
}
int DescribeGWSInstancesResult::getTotalCount()const
{
return totalCount_;
}
int DescribeGWSInstancesResult::getPageSize()const
{
return pageSize_;
}
int DescribeGWSInstancesResult::getPageNumber()const
{
return pageNumber_;
}

View File

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

View File

@@ -1,74 +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/DescribeImageGatewayConfigResult.h>
#include <json/json.h>
using namespace AlibabaCloud::EHPC;
using namespace AlibabaCloud::EHPC::Model;
DescribeImageGatewayConfigResult::DescribeImageGatewayConfigResult() :
ServiceResult()
{}
DescribeImageGatewayConfigResult::DescribeImageGatewayConfigResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
DescribeImageGatewayConfigResult::~DescribeImageGatewayConfigResult()
{}
void DescribeImageGatewayConfigResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
auto imagegwNode = value["Imagegw"];
if(!imagegwNode["UpdateDateTime"].isNull())
imagegw_.updateDateTime = imagegwNode["UpdateDateTime"].asString();
if(!imagegwNode["ImageExpirationTimeout"].isNull())
imagegw_.imageExpirationTimeout = imagegwNode["ImageExpirationTimeout"].asString();
if(!imagegwNode["MongoDBURI"].isNull())
imagegw_.mongoDBURI = imagegwNode["MongoDBURI"].asString();
if(!imagegwNode["DefaultImageLocation"].isNull())
imagegw_.defaultImageLocation = imagegwNode["DefaultImageLocation"].asString();
if(!imagegwNode["PullUpdateTimeout"].isNull())
imagegw_.pullUpdateTimeout = std::stol(imagegwNode["PullUpdateTimeout"].asString());
auto allLocationsNode = imagegwNode["Locations"]["LocationInfo"];
for (auto imagegwNodeLocationsLocationInfo : allLocationsNode)
{
Imagegw::LocationInfo locationInfoObject;
if(!imagegwNodeLocationsLocationInfo["URL"].isNull())
locationInfoObject.uRL = imagegwNodeLocationsLocationInfo["URL"].asString();
if(!imagegwNodeLocationsLocationInfo["RemoteType"].isNull())
locationInfoObject.remoteType = imagegwNodeLocationsLocationInfo["RemoteType"].asString();
if(!imagegwNodeLocationsLocationInfo["Location"].isNull())
locationInfoObject.location = imagegwNodeLocationsLocationInfo["Location"].asString();
if(!imagegwNodeLocationsLocationInfo["Authentication"].isNull())
locationInfoObject.authentication = imagegwNodeLocationsLocationInfo["Authentication"].asString();
imagegw_.locations.push_back(locationInfoObject);
}
}
DescribeImageGatewayConfigResult::Imagegw DescribeImageGatewayConfigResult::getImagegw()const
{
return imagegw_;
}

View File

@@ -1,90 +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/DescribeImagePriceRequest.h>
using AlibabaCloud::EHPC::Model::DescribeImagePriceRequest;
DescribeImagePriceRequest::DescribeImagePriceRequest()
: RpcServiceRequest("ehpc", "2018-04-12", "DescribeImagePrice") {
setMethod(HttpRequest::Method::Get);
}
DescribeImagePriceRequest::~DescribeImagePriceRequest() {}
int DescribeImagePriceRequest::getPeriod() const {
return period_;
}
void DescribeImagePriceRequest::setPeriod(int period) {
period_ = period;
setParameter(std::string("Period"), std::to_string(period));
}
int DescribeImagePriceRequest::getAmount() const {
return amount_;
}
void DescribeImagePriceRequest::setAmount(int amount) {
amount_ = amount;
setParameter(std::string("Amount"), std::to_string(amount));
}
std::string DescribeImagePriceRequest::getImageId() const {
return imageId_;
}
void DescribeImagePriceRequest::setImageId(const std::string &imageId) {
imageId_ = imageId;
setParameter(std::string("ImageId"), imageId);
}
std::string DescribeImagePriceRequest::getSkuCode() const {
return skuCode_;
}
void DescribeImagePriceRequest::setSkuCode(const std::string &skuCode) {
skuCode_ = skuCode;
setParameter(std::string("SkuCode"), skuCode);
}
std::string DescribeImagePriceRequest::getAccessKeyId() const {
return accessKeyId_;
}
void DescribeImagePriceRequest::setAccessKeyId(const std::string &accessKeyId) {
accessKeyId_ = accessKeyId;
setParameter(std::string("AccessKeyId"), accessKeyId);
}
std::string DescribeImagePriceRequest::getPriceUnit() const {
return priceUnit_;
}
void DescribeImagePriceRequest::setPriceUnit(const std::string &priceUnit) {
priceUnit_ = priceUnit;
setParameter(std::string("PriceUnit"), priceUnit);
}
std::string DescribeImagePriceRequest::getOrderType() const {
return orderType_;
}
void DescribeImagePriceRequest::setOrderType(const std::string &orderType) {
orderType_ = orderType;
setParameter(std::string("OrderType"), orderType);
}

View File

@@ -1,79 +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/DescribeImagePriceResult.h>
#include <json/json.h>
using namespace AlibabaCloud::EHPC;
using namespace AlibabaCloud::EHPC::Model;
DescribeImagePriceResult::DescribeImagePriceResult() :
ServiceResult()
{}
DescribeImagePriceResult::DescribeImagePriceResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
DescribeImagePriceResult::~DescribeImagePriceResult()
{}
void DescribeImagePriceResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
if(!value["Amount"].isNull())
amount_ = std::stoi(value["Amount"].asString());
if(!value["DiscountPrice"].isNull())
discountPrice_ = std::stof(value["DiscountPrice"].asString());
if(!value["TradePrice"].isNull())
tradePrice_ = std::stof(value["TradePrice"].asString());
if(!value["OriginalPrice"].isNull())
originalPrice_ = std::stof(value["OriginalPrice"].asString());
if(!value["ImageId"].isNull())
imageId_ = value["ImageId"].asString();
}
float DescribeImagePriceResult::getOriginalPrice()const
{
return originalPrice_;
}
int DescribeImagePriceResult::getAmount()const
{
return amount_;
}
float DescribeImagePriceResult::getDiscountPrice()const
{
return discountPrice_;
}
std::string DescribeImagePriceResult::getImageId()const
{
return imageId_;
}
float DescribeImagePriceResult::getTradePrice()const
{
return tradePrice_;
}

View File

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

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

View File

@@ -0,0 +1,65 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/ehpc/model/DescribeJobMetricDataRequest.h>
using AlibabaCloud::EHPC::Model::DescribeJobMetricDataRequest;
DescribeJobMetricDataRequest::DescribeJobMetricDataRequest()
: RpcServiceRequest("ehpc", "2023-07-01", "DescribeJobMetricData") {
setMethod(HttpRequest::Method::Post);
}
DescribeJobMetricDataRequest::~DescribeJobMetricDataRequest() {}
std::string DescribeJobMetricDataRequest::getTaskName() const {
return taskName_;
}
void DescribeJobMetricDataRequest::setTaskName(const std::string &taskName) {
taskName_ = taskName;
setParameter(std::string("TaskName"), taskName);
}
std::string DescribeJobMetricDataRequest::getJobId() const {
return jobId_;
}
void DescribeJobMetricDataRequest::setJobId(const std::string &jobId) {
jobId_ = jobId;
setParameter(std::string("JobId"), jobId);
}
std::string DescribeJobMetricDataRequest::getMetricName() const {
return metricName_;
}
void DescribeJobMetricDataRequest::setMetricName(const std::string &metricName) {
metricName_ = metricName;
setParameter(std::string("MetricName"), metricName);
}
std::vector<DescribeJobMetricDataRequest::int> DescribeJobMetricDataRequest::getArrayIndex() const {
return arrayIndex_;
}
void DescribeJobMetricDataRequest::setArrayIndex(const std::vector<DescribeJobMetricDataRequest::int> &arrayIndex) {
arrayIndex_ = arrayIndex;
for(int dep1 = 0; dep1 != arrayIndex.size(); dep1++) {
setParameter(std::string("ArrayIndex") + "." + std::to_string(dep1 + 1), std::to_string(arrayIndex[dep1]));
}
}

View File

@@ -14,45 +14,45 @@
* limitations under the License.
*/
#include <alibabacloud/ehpc/model/CreateClusterResult.h>
#include <alibabacloud/ehpc/model/DescribeJobMetricDataResult.h>
#include <json/json.h>
using namespace AlibabaCloud::EHPC;
using namespace AlibabaCloud::EHPC::Model;
CreateClusterResult::CreateClusterResult() :
DescribeJobMetricDataResult::DescribeJobMetricDataResult() :
ServiceResult()
{}
CreateClusterResult::CreateClusterResult(const std::string &payload) :
DescribeJobMetricDataResult::DescribeJobMetricDataResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
CreateClusterResult::~CreateClusterResult()
DescribeJobMetricDataResult::~DescribeJobMetricDataResult()
{}
void CreateClusterResult::parse(const std::string &payload)
void DescribeJobMetricDataResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
if(!value["TaskId"].isNull())
taskId_ = value["TaskId"].asString();
if(!value["ClusterId"].isNull())
clusterId_ = value["ClusterId"].asString();
if(!value["Period"].isNull())
period_ = std::stoi(value["Period"].asString());
if(!value["DataPoints"].isNull())
dataPoints_ = value["DataPoints"].asString();
}
std::string CreateClusterResult::getTaskId()const
int DescribeJobMetricDataResult::getPeriod()const
{
return taskId_;
return period_;
}
std::string CreateClusterResult::getClusterId()const
std::string DescribeJobMetricDataResult::getDataPoints()const
{
return clusterId_;
return dataPoints_;
}

View File

@@ -0,0 +1,56 @@
/*
* 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/DescribeJobMetricLastRequest.h>
using AlibabaCloud::EHPC::Model::DescribeJobMetricLastRequest;
DescribeJobMetricLastRequest::DescribeJobMetricLastRequest()
: RpcServiceRequest("ehpc", "2023-07-01", "DescribeJobMetricLast") {
setMethod(HttpRequest::Method::Post);
}
DescribeJobMetricLastRequest::~DescribeJobMetricLastRequest() {}
std::string DescribeJobMetricLastRequest::getTaskName() const {
return taskName_;
}
void DescribeJobMetricLastRequest::setTaskName(const std::string &taskName) {
taskName_ = taskName;
setParameter(std::string("TaskName"), taskName);
}
std::string DescribeJobMetricLastRequest::getJobId() const {
return jobId_;
}
void DescribeJobMetricLastRequest::setJobId(const std::string &jobId) {
jobId_ = jobId;
setParameter(std::string("JobId"), jobId);
}
std::vector<DescribeJobMetricLastRequest::int> DescribeJobMetricLastRequest::getArrayIndex() const {
return arrayIndex_;
}
void DescribeJobMetricLastRequest::setArrayIndex(const std::vector<DescribeJobMetricLastRequest::int> &arrayIndex) {
arrayIndex_ = arrayIndex;
for(int dep1 = 0; dep1 != arrayIndex.size(); dep1++) {
setParameter(std::string("ArrayIndex") + "." + std::to_string(dep1 + 1), std::to_string(arrayIndex[dep1]));
}
}

View File

@@ -14,46 +14,46 @@
* limitations under the License.
*/
#include <alibabacloud/ehpc/model/ListRegionsResult.h>
#include <alibabacloud/ehpc/model/DescribeJobMetricLastResult.h>
#include <json/json.h>
using namespace AlibabaCloud::EHPC;
using namespace AlibabaCloud::EHPC::Model;
ListRegionsResult::ListRegionsResult() :
DescribeJobMetricLastResult::DescribeJobMetricLastResult() :
ServiceResult()
{}
ListRegionsResult::ListRegionsResult(const std::string &payload) :
DescribeJobMetricLastResult::DescribeJobMetricLastResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
ListRegionsResult::~ListRegionsResult()
DescribeJobMetricLastResult::~DescribeJobMetricLastResult()
{}
void ListRegionsResult::parse(const std::string &payload)
void DescribeJobMetricLastResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
auto allRegionsNode = value["Regions"]["RegionInfo"];
for (auto valueRegionsRegionInfo : allRegionsNode)
auto allMetricsNode = value["Metrics"]["MetricInfo"];
for (auto valueMetricsMetricInfo : allMetricsNode)
{
RegionInfo regionsObject;
if(!valueRegionsRegionInfo["LocalName"].isNull())
regionsObject.localName = valueRegionsRegionInfo["LocalName"].asString();
if(!valueRegionsRegionInfo["RegionId"].isNull())
regionsObject.regionId = valueRegionsRegionInfo["RegionId"].asString();
regions_.push_back(regionsObject);
MetricInfo metricsObject;
if(!valueMetricsMetricInfo["ArrayIndex"].isNull())
metricsObject.arrayIndex = std::stoi(valueMetricsMetricInfo["ArrayIndex"].asString());
if(!valueMetricsMetricInfo["Metric"].isNull())
metricsObject.metric = valueMetricsMetricInfo["Metric"].asString();
metrics_.push_back(metricsObject);
}
}
std::vector<ListRegionsResult::RegionInfo> ListRegionsResult::getRegions()const
std::vector<DescribeJobMetricLastResult::MetricInfo> DescribeJobMetricLastResult::getMetrics()const
{
return regions_;
return metrics_;
}

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.
*/
#include <alibabacloud/ehpc/model/DescribeJobRequest.h>
using AlibabaCloud::EHPC::Model::DescribeJobRequest;
DescribeJobRequest::DescribeJobRequest()
: RpcServiceRequest("ehpc", "2018-04-12", "DescribeJob") {
setMethod(HttpRequest::Method::Get);
}
DescribeJobRequest::~DescribeJobRequest() {}
std::string DescribeJobRequest::getClusterId() const {
return clusterId_;
}
void DescribeJobRequest::setClusterId(const std::string &clusterId) {
clusterId_ = clusterId;
setParameter(std::string("ClusterId"), clusterId);
}
std::string DescribeJobRequest::getAccessKeyId() const {
return accessKeyId_;
}
void DescribeJobRequest::setAccessKeyId(const std::string &accessKeyId) {
accessKeyId_ = accessKeyId;
setParameter(std::string("AccessKeyId"), accessKeyId);
}
std::string DescribeJobRequest::getJobId() const {
return jobId_;
}
void DescribeJobRequest::setJobId(const std::string &jobId) {
jobId_ = jobId;
setParameter(std::string("JobId"), jobId);
}
bool DescribeJobRequest::getAsync() const {
return async_;
}
void DescribeJobRequest::setAsync(bool async) {
async_ = async;
setParameter(std::string("Async"), async ? "true" : "false");
}

View File

@@ -1,52 +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/DescribeJobResult.h>
#include <json/json.h>
using namespace AlibabaCloud::EHPC;
using namespace AlibabaCloud::EHPC::Model;
DescribeJobResult::DescribeJobResult() :
ServiceResult()
{}
DescribeJobResult::DescribeJobResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
DescribeJobResult::~DescribeJobResult()
{}
void DescribeJobResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
auto messageNode = value["Message"];
if(!messageNode["JobInfo"].isNull())
message_.jobInfo = messageNode["JobInfo"].asString();
}
DescribeJobResult::Message DescribeJobResult::getMessage()const
{
return message_;
}

View File

@@ -1,45 +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/DescribeNFSClientStatusRequest.h>
using AlibabaCloud::EHPC::Model::DescribeNFSClientStatusRequest;
DescribeNFSClientStatusRequest::DescribeNFSClientStatusRequest()
: RpcServiceRequest("ehpc", "2018-04-12", "DescribeNFSClientStatus") {
setMethod(HttpRequest::Method::Get);
}
DescribeNFSClientStatusRequest::~DescribeNFSClientStatusRequest() {}
std::string DescribeNFSClientStatusRequest::getAccessKeyId() const {
return accessKeyId_;
}
void DescribeNFSClientStatusRequest::setAccessKeyId(const std::string &accessKeyId) {
accessKeyId_ = accessKeyId;
setParameter(std::string("AccessKeyId"), accessKeyId);
}
std::string DescribeNFSClientStatusRequest::getInstanceId() const {
return instanceId_;
}
void DescribeNFSClientStatusRequest::setInstanceId(const std::string &instanceId) {
instanceId_ = instanceId;
setParameter(std::string("InstanceId"), instanceId);
}

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.
*/
#include <alibabacloud/ehpc/model/DescribeNFSClientStatusResult.h>
#include <json/json.h>
using namespace AlibabaCloud::EHPC;
using namespace AlibabaCloud::EHPC::Model;
DescribeNFSClientStatusResult::DescribeNFSClientStatusResult() :
ServiceResult()
{}
DescribeNFSClientStatusResult::DescribeNFSClientStatusResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
DescribeNFSClientStatusResult::~DescribeNFSClientStatusResult()
{}
void DescribeNFSClientStatusResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
auto resultNode = value["Result"];
if(!resultNode["Output"].isNull())
result_.output = resultNode["Output"].asString();
if(!resultNode["InvokeRecordStatus"].isNull())
result_.invokeRecordStatus = resultNode["InvokeRecordStatus"].asString();
if(!resultNode["ExitCode"].isNull())
result_.exitCode = std::stoi(resultNode["ExitCode"].asString());
if(!value["Status"].isNull())
status_ = value["Status"].asString();
}
std::string DescribeNFSClientStatusResult::getStatus()const
{
return status_;
}
DescribeNFSClientStatusResult::Result DescribeNFSClientStatusResult::getResult()const
{
return result_;
}

View File

@@ -1,94 +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/DescribePriceRequest.h>
using AlibabaCloud::EHPC::Model::DescribePriceRequest;
DescribePriceRequest::DescribePriceRequest()
: RpcServiceRequest("ehpc", "2018-04-12", "DescribePrice") {
setMethod(HttpRequest::Method::Get);
}
DescribePriceRequest::~DescribePriceRequest() {}
std::vector<DescribePriceRequest::Commodities> DescribePriceRequest::getCommodities() const {
return commodities_;
}
void DescribePriceRequest::setCommodities(const std::vector<DescribePriceRequest::Commodities> &commodities) {
commodities_ = commodities;
for(int dep1 = 0; dep1 != commodities.size(); dep1++) {
auto commoditiesObj = commodities.at(dep1);
std::string commoditiesObjStr = std::string("Commodities") + "." + std::to_string(dep1 + 1);
setParameter(commoditiesObjStr + ".Amount", std::to_string(commoditiesObj.amount));
setParameter(commoditiesObjStr + ".Period", std::to_string(commoditiesObj.period));
setParameter(commoditiesObjStr + ".NodeType", commoditiesObj.nodeType);
for(int dep2 = 0; dep2 != commoditiesObj.dataDisks.size(); dep2++) {
auto dataDisksObj = commoditiesObj.dataDisks.at(dep2);
std::string dataDisksObjStr = commoditiesObjStr + ".DataDisks" + "." + std::to_string(dep2 + 1);
setParameter(dataDisksObjStr + ".size", std::to_string(dataDisksObj.size));
setParameter(dataDisksObjStr + ".encrypted", dataDisksObj.encrypted ? "true" : "false");
setParameter(dataDisksObjStr + ".performanceLevel", dataDisksObj.performanceLevel);
setParameter(dataDisksObjStr + ".category", dataDisksObj.category);
setParameter(dataDisksObjStr + ".deleteWithInstance", dataDisksObj.deleteWithInstance ? "true" : "false");
}
setParameter(commoditiesObjStr + ".SystemDiskCategory", commoditiesObj.systemDiskCategory);
setParameter(commoditiesObjStr + ".InternetChargeType", commoditiesObj.internetChargeType);
setParameter(commoditiesObjStr + ".SystemDiskPerformanceLevel", commoditiesObj.systemDiskPerformanceLevel);
setParameter(commoditiesObjStr + ".SystemDiskSize", std::to_string(commoditiesObj.systemDiskSize));
setParameter(commoditiesObjStr + ".InternetMaxBandWidthOut", std::to_string(commoditiesObj.internetMaxBandWidthOut));
setParameter(commoditiesObjStr + ".InstanceType", commoditiesObj.instanceType);
setParameter(commoditiesObjStr + ".NetworkType", commoditiesObj.networkType);
}
}
std::string DescribePriceRequest::getAccessKeyId() const {
return accessKeyId_;
}
void DescribePriceRequest::setAccessKeyId(const std::string &accessKeyId) {
accessKeyId_ = accessKeyId;
setParameter(std::string("AccessKeyId"), accessKeyId);
}
std::string DescribePriceRequest::getPriceUnit() const {
return priceUnit_;
}
void DescribePriceRequest::setPriceUnit(const std::string &priceUnit) {
priceUnit_ = priceUnit;
setParameter(std::string("PriceUnit"), priceUnit);
}
std::string DescribePriceRequest::getChargeType() const {
return chargeType_;
}
void DescribePriceRequest::setChargeType(const std::string &chargeType) {
chargeType_ = chargeType;
setParameter(std::string("ChargeType"), chargeType);
}
std::string DescribePriceRequest::getOrderType() const {
return orderType_;
}
void DescribePriceRequest::setOrderType(const std::string &orderType) {
orderType_ = orderType;
setParameter(std::string("OrderType"), orderType);
}

View File

@@ -1,70 +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/DescribePriceResult.h>
#include <json/json.h>
using namespace AlibabaCloud::EHPC;
using namespace AlibabaCloud::EHPC::Model;
DescribePriceResult::DescribePriceResult() :
ServiceResult()
{}
DescribePriceResult::DescribePriceResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
DescribePriceResult::~DescribePriceResult()
{}
void DescribePriceResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
auto allPricesNode = value["Prices"]["PriceInfo"];
for (auto valuePricesPriceInfo : allPricesNode)
{
PriceInfo pricesObject;
if(!valuePricesPriceInfo["OriginalPrice"].isNull())
pricesObject.originalPrice = std::stof(valuePricesPriceInfo["OriginalPrice"].asString());
if(!valuePricesPriceInfo["NodeType"].isNull())
pricesObject.nodeType = valuePricesPriceInfo["NodeType"].asString();
if(!valuePricesPriceInfo["Currency"].isNull())
pricesObject.currency = valuePricesPriceInfo["Currency"].asString();
if(!valuePricesPriceInfo["TradePrice"].isNull())
pricesObject.tradePrice = std::stof(valuePricesPriceInfo["TradePrice"].asString());
prices_.push_back(pricesObject);
}
if(!value["TotalTradePrice"].isNull())
totalTradePrice_ = std::stof(value["TotalTradePrice"].asString());
}
std::vector<DescribePriceResult::PriceInfo> DescribePriceResult::getPrices()const
{
return prices_;
}
float DescribePriceResult::getTotalTradePrice()const
{
return totalTradePrice_;
}

View File

@@ -1,56 +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/DescribeServerlessJobsRequest.h>
using AlibabaCloud::EHPC::Model::DescribeServerlessJobsRequest;
DescribeServerlessJobsRequest::DescribeServerlessJobsRequest()
: RpcServiceRequest("ehpc", "2018-04-12", "DescribeServerlessJobs") {
setMethod(HttpRequest::Method::Post);
}
DescribeServerlessJobsRequest::~DescribeServerlessJobsRequest() {}
std::string DescribeServerlessJobsRequest::getClusterId() const {
return clusterId_;
}
void DescribeServerlessJobsRequest::setClusterId(const std::string &clusterId) {
clusterId_ = clusterId;
setParameter(std::string("ClusterId"), clusterId);
}
std::string DescribeServerlessJobsRequest::getAccessKeyId() const {
return accessKeyId_;
}
void DescribeServerlessJobsRequest::setAccessKeyId(const std::string &accessKeyId) {
accessKeyId_ = accessKeyId;
setParameter(std::string("AccessKeyId"), accessKeyId);
}
std::vector<DescribeServerlessJobsRequest::std::string> DescribeServerlessJobsRequest::getJobIds() const {
return jobIds_;
}
void DescribeServerlessJobsRequest::setJobIds(const std::vector<DescribeServerlessJobsRequest::std::string> &jobIds) {
jobIds_ = jobIds;
for(int dep1 = 0; dep1 != jobIds.size(); dep1++) {
setParameter(std::string("JobIds") + "." + std::to_string(dep1 + 1), jobIds[dep1]);
}
}

View File

@@ -1,548 +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/DescribeServerlessJobsResult.h>
#include <json/json.h>
using namespace AlibabaCloud::EHPC;
using namespace AlibabaCloud::EHPC::Model;
DescribeServerlessJobsResult::DescribeServerlessJobsResult() :
ServiceResult()
{}
DescribeServerlessJobsResult::DescribeServerlessJobsResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
DescribeServerlessJobsResult::~DescribeServerlessJobsResult()
{}
void DescribeServerlessJobsResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
auto allJobInfosNode = value["JobInfos"]["JobInfo"];
for (auto valueJobInfosJobInfo : allJobInfosNode)
{
JobInfo jobInfosObject;
if(!valueJobInfosJobInfo["JobId"].isNull())
jobInfosObject.jobId = valueJobInfosJobInfo["JobId"].asString();
if(!valueJobInfosJobInfo["JobName"].isNull())
jobInfosObject.jobName = valueJobInfosJobInfo["JobName"].asString();
if(!valueJobInfosJobInfo["State"].isNull())
jobInfosObject.state = valueJobInfosJobInfo["State"].asString();
if(!valueJobInfosJobInfo["Priority"].isNull())
jobInfosObject.priority = std::stol(valueJobInfosJobInfo["Priority"].asString());
if(!valueJobInfosJobInfo["Queue"].isNull())
jobInfosObject.queue = valueJobInfosJobInfo["Queue"].asString();
if(!valueJobInfosJobInfo["User"].isNull())
jobInfosObject.user = valueJobInfosJobInfo["User"].asString();
if(!valueJobInfosJobInfo["SubmitTime"].isNull())
jobInfosObject.submitTime = std::stol(valueJobInfosJobInfo["SubmitTime"].asString());
if(!valueJobInfosJobInfo["StartTime"].isNull())
jobInfosObject.startTime = std::stol(valueJobInfosJobInfo["StartTime"].asString());
if(!valueJobInfosJobInfo["EndTime"].isNull())
jobInfosObject.endTime = std::stol(valueJobInfosJobInfo["EndTime"].asString());
if(!valueJobInfosJobInfo["LastModifyTime"].isNull())
jobInfosObject.lastModifyTime = std::stol(valueJobInfosJobInfo["LastModifyTime"].asString());
if(!valueJobInfosJobInfo["IsArrayJob"].isNull())
jobInfosObject.isArrayJob = valueJobInfosJobInfo["IsArrayJob"].asString() == "true";
auto allContainerGroupsNode = valueJobInfosJobInfo["ContainerGroups"]["ContainerGroup"];
for (auto valueJobInfosJobInfoContainerGroupsContainerGroup : allContainerGroupsNode)
{
JobInfo::ContainerGroup containerGroupsObject;
if(!valueJobInfosJobInfoContainerGroupsContainerGroup["ContainerGroupId"].isNull())
containerGroupsObject.containerGroupId = valueJobInfosJobInfoContainerGroupsContainerGroup["ContainerGroupId"].asString();
if(!valueJobInfosJobInfoContainerGroupsContainerGroup["ContainerGroupName"].isNull())
containerGroupsObject.containerGroupName = valueJobInfosJobInfoContainerGroupsContainerGroup["ContainerGroupName"].asString();
if(!valueJobInfosJobInfoContainerGroupsContainerGroup["Status"].isNull())
containerGroupsObject.status = valueJobInfosJobInfoContainerGroupsContainerGroup["Status"].asString();
if(!valueJobInfosJobInfoContainerGroupsContainerGroup["InstanceType"].isNull())
containerGroupsObject.instanceType = valueJobInfosJobInfoContainerGroupsContainerGroup["InstanceType"].asString();
if(!valueJobInfosJobInfoContainerGroupsContainerGroup["SpotStrategy"].isNull())
containerGroupsObject.spotStrategy = valueJobInfosJobInfoContainerGroupsContainerGroup["SpotStrategy"].asString();
if(!valueJobInfosJobInfoContainerGroupsContainerGroup["SpotPriceLimit"].isNull())
containerGroupsObject.spotPriceLimit = std::stof(valueJobInfosJobInfoContainerGroupsContainerGroup["SpotPriceLimit"].asString());
if(!valueJobInfosJobInfoContainerGroupsContainerGroup["Cpu"].isNull())
containerGroupsObject.cpu = std::stof(valueJobInfosJobInfoContainerGroupsContainerGroup["Cpu"].asString());
if(!valueJobInfosJobInfoContainerGroupsContainerGroup["Memory"].isNull())
containerGroupsObject.memory = std::stof(valueJobInfosJobInfoContainerGroupsContainerGroup["Memory"].asString());
if(!valueJobInfosJobInfoContainerGroupsContainerGroup["CreationTime"].isNull())
containerGroupsObject.creationTime = valueJobInfosJobInfoContainerGroupsContainerGroup["CreationTime"].asString();
if(!valueJobInfosJobInfoContainerGroupsContainerGroup["SucceededTime"].isNull())
containerGroupsObject.succeededTime = valueJobInfosJobInfoContainerGroupsContainerGroup["SucceededTime"].asString();
if(!valueJobInfosJobInfoContainerGroupsContainerGroup["ExpiredTime"].isNull())
containerGroupsObject.expiredTime = valueJobInfosJobInfoContainerGroupsContainerGroup["ExpiredTime"].asString();
if(!valueJobInfosJobInfoContainerGroupsContainerGroup["FailedTime"].isNull())
containerGroupsObject.failedTime = valueJobInfosJobInfoContainerGroupsContainerGroup["FailedTime"].asString();
if(!valueJobInfosJobInfoContainerGroupsContainerGroup["Discount"].isNull())
containerGroupsObject.discount = std::stol(valueJobInfosJobInfoContainerGroupsContainerGroup["Discount"].asString());
if(!valueJobInfosJobInfoContainerGroupsContainerGroup["EniInstanceId"].isNull())
containerGroupsObject.eniInstanceId = valueJobInfosJobInfoContainerGroupsContainerGroup["EniInstanceId"].asString();
if(!valueJobInfosJobInfoContainerGroupsContainerGroup["EphemeralStorage"].isNull())
containerGroupsObject.ephemeralStorage = std::stol(valueJobInfosJobInfoContainerGroupsContainerGroup["EphemeralStorage"].asString());
if(!valueJobInfosJobInfoContainerGroupsContainerGroup["InternetIp"].isNull())
containerGroupsObject.internetIp = valueJobInfosJobInfoContainerGroupsContainerGroup["InternetIp"].asString();
if(!valueJobInfosJobInfoContainerGroupsContainerGroup["IntranetIp"].isNull())
containerGroupsObject.intranetIp = valueJobInfosJobInfoContainerGroupsContainerGroup["IntranetIp"].asString();
if(!valueJobInfosJobInfoContainerGroupsContainerGroup["Ipv6Address"].isNull())
containerGroupsObject.ipv6Address = valueJobInfosJobInfoContainerGroupsContainerGroup["Ipv6Address"].asString();
if(!valueJobInfosJobInfoContainerGroupsContainerGroup["RamRoleName"].isNull())
containerGroupsObject.ramRoleName = valueJobInfosJobInfoContainerGroupsContainerGroup["RamRoleName"].asString();
if(!valueJobInfosJobInfoContainerGroupsContainerGroup["RegionId"].isNull())
containerGroupsObject.regionId = valueJobInfosJobInfoContainerGroupsContainerGroup["RegionId"].asString();
if(!valueJobInfosJobInfoContainerGroupsContainerGroup["ResourceGroupId"].isNull())
containerGroupsObject.resourceGroupId = valueJobInfosJobInfoContainerGroupsContainerGroup["ResourceGroupId"].asString();
if(!valueJobInfosJobInfoContainerGroupsContainerGroup["RestartPolicy"].isNull())
containerGroupsObject.restartPolicy = valueJobInfosJobInfoContainerGroupsContainerGroup["RestartPolicy"].asString();
if(!valueJobInfosJobInfoContainerGroupsContainerGroup["SecurityGroupId"].isNull())
containerGroupsObject.securityGroupId = valueJobInfosJobInfoContainerGroupsContainerGroup["SecurityGroupId"].asString();
if(!valueJobInfosJobInfoContainerGroupsContainerGroup["TenantEniInstanceId"].isNull())
containerGroupsObject.tenantEniInstanceId = valueJobInfosJobInfoContainerGroupsContainerGroup["TenantEniInstanceId"].asString();
if(!valueJobInfosJobInfoContainerGroupsContainerGroup["TenantEniIp"].isNull())
containerGroupsObject.tenantEniIp = valueJobInfosJobInfoContainerGroupsContainerGroup["TenantEniIp"].asString();
if(!valueJobInfosJobInfoContainerGroupsContainerGroup["TenantSecurityGroupId"].isNull())
containerGroupsObject.tenantSecurityGroupId = valueJobInfosJobInfoContainerGroupsContainerGroup["TenantSecurityGroupId"].asString();
if(!valueJobInfosJobInfoContainerGroupsContainerGroup["TenantVSwitchId"].isNull())
containerGroupsObject.tenantVSwitchId = valueJobInfosJobInfoContainerGroupsContainerGroup["TenantVSwitchId"].asString();
if(!valueJobInfosJobInfoContainerGroupsContainerGroup["VSwitchId"].isNull())
containerGroupsObject.vSwitchId = valueJobInfosJobInfoContainerGroupsContainerGroup["VSwitchId"].asString();
if(!valueJobInfosJobInfoContainerGroupsContainerGroup["VpcId"].isNull())
containerGroupsObject.vpcId = valueJobInfosJobInfoContainerGroupsContainerGroup["VpcId"].asString();
if(!valueJobInfosJobInfoContainerGroupsContainerGroup["ZoneId"].isNull())
containerGroupsObject.zoneId = valueJobInfosJobInfoContainerGroupsContainerGroup["ZoneId"].asString();
auto allContainersNode = valueJobInfosJobInfoContainerGroupsContainerGroup["Containers"]["Container"];
for (auto valueJobInfosJobInfoContainerGroupsContainerGroupContainersContainer : allContainersNode)
{
JobInfo::ContainerGroup::Container containersObject;
if(!valueJobInfosJobInfoContainerGroupsContainerGroupContainersContainer["Cpu"].isNull())
containersObject.cpu = std::stof(valueJobInfosJobInfoContainerGroupsContainerGroupContainersContainer["Cpu"].asString());
if(!valueJobInfosJobInfoContainerGroupsContainerGroupContainersContainer["Gpu"].isNull())
containersObject.gpu = std::stoi(valueJobInfosJobInfoContainerGroupsContainerGroupContainersContainer["Gpu"].asString());
if(!valueJobInfosJobInfoContainerGroupsContainerGroupContainersContainer["Image"].isNull())
containersObject.image = valueJobInfosJobInfoContainerGroupsContainerGroupContainersContainer["Image"].asString();
if(!valueJobInfosJobInfoContainerGroupsContainerGroupContainersContainer["ImagePullPolicy"].isNull())
containersObject.imagePullPolicy = valueJobInfosJobInfoContainerGroupsContainerGroupContainersContainer["ImagePullPolicy"].asString();
if(!valueJobInfosJobInfoContainerGroupsContainerGroupContainersContainer["Memory"].isNull())
containersObject.memory = std::stof(valueJobInfosJobInfoContainerGroupsContainerGroupContainersContainer["Memory"].asString());
if(!valueJobInfosJobInfoContainerGroupsContainerGroupContainersContainer["Name"].isNull())
containersObject.name = valueJobInfosJobInfoContainerGroupsContainerGroupContainersContainer["Name"].asString();
if(!valueJobInfosJobInfoContainerGroupsContainerGroupContainersContainer["Ready"].isNull())
containersObject.ready = valueJobInfosJobInfoContainerGroupsContainerGroupContainersContainer["Ready"].asString() == "true";
if(!valueJobInfosJobInfoContainerGroupsContainerGroupContainersContainer["RestartCount"].isNull())
containersObject.restartCount = std::stoi(valueJobInfosJobInfoContainerGroupsContainerGroupContainersContainer["RestartCount"].asString());
if(!valueJobInfosJobInfoContainerGroupsContainerGroupContainersContainer["Stdin"].isNull())
containersObject.stdin = valueJobInfosJobInfoContainerGroupsContainerGroupContainersContainer["Stdin"].asString() == "true";
if(!valueJobInfosJobInfoContainerGroupsContainerGroupContainersContainer["StdinOnce"].isNull())
containersObject.stdinOnce = valueJobInfosJobInfoContainerGroupsContainerGroupContainersContainer["StdinOnce"].asString() == "true";
if(!valueJobInfosJobInfoContainerGroupsContainerGroupContainersContainer["Tty"].isNull())
containersObject.tty = valueJobInfosJobInfoContainerGroupsContainerGroupContainersContainer["Tty"].asString() == "true";
if(!valueJobInfosJobInfoContainerGroupsContainerGroupContainersContainer["WorkingDir"].isNull())
containersObject.workingDir = valueJobInfosJobInfoContainerGroupsContainerGroupContainersContainer["WorkingDir"].asString();
auto allEnvironmentVarsNode = valueJobInfosJobInfoContainerGroupsContainerGroupContainersContainer["EnvironmentVars"]["EnvironmentVar"];
for (auto valueJobInfosJobInfoContainerGroupsContainerGroupContainersContainerEnvironmentVarsEnvironmentVar : allEnvironmentVarsNode)
{
JobInfo::ContainerGroup::Container::EnvironmentVar environmentVarsObject;
if(!valueJobInfosJobInfoContainerGroupsContainerGroupContainersContainerEnvironmentVarsEnvironmentVar["Key"].isNull())
environmentVarsObject.key = valueJobInfosJobInfoContainerGroupsContainerGroupContainersContainerEnvironmentVarsEnvironmentVar["Key"].asString();
if(!valueJobInfosJobInfoContainerGroupsContainerGroupContainersContainerEnvironmentVarsEnvironmentVar["Value"].isNull())
environmentVarsObject.value = valueJobInfosJobInfoContainerGroupsContainerGroupContainersContainerEnvironmentVarsEnvironmentVar["Value"].asString();
auto valueFromNode = value["ValueFrom"];
auto fieldRefNode = valueFromNode["FieldRef"];
if(!fieldRefNode["FieldPath"].isNull())
environmentVarsObject.valueFrom.fieldRef.fieldPath = fieldRefNode["FieldPath"].asString();
containersObject.environmentVars.push_back(environmentVarsObject);
}
auto allPortsNode = valueJobInfosJobInfoContainerGroupsContainerGroupContainersContainer["Ports"]["Port"];
for (auto valueJobInfosJobInfoContainerGroupsContainerGroupContainersContainerPortsPort : allPortsNode)
{
JobInfo::ContainerGroup::Container::Port portsObject;
if(!valueJobInfosJobInfoContainerGroupsContainerGroupContainersContainerPortsPort["Port"].isNull())
portsObject.port = std::stol(valueJobInfosJobInfoContainerGroupsContainerGroupContainersContainerPortsPort["Port"].asString());
if(!valueJobInfosJobInfoContainerGroupsContainerGroupContainersContainerPortsPort["Protocol"].isNull())
portsObject.protocol = valueJobInfosJobInfoContainerGroupsContainerGroupContainersContainerPortsPort["Protocol"].asString();
containersObject.ports.push_back(portsObject);
}
auto allVolumeMountsNode = valueJobInfosJobInfoContainerGroupsContainerGroupContainersContainer["VolumeMounts"]["VolumeMount"];
for (auto valueJobInfosJobInfoContainerGroupsContainerGroupContainersContainerVolumeMountsVolumeMount : allVolumeMountsNode)
{
JobInfo::ContainerGroup::Container::VolumeMount volumeMountsObject;
if(!valueJobInfosJobInfoContainerGroupsContainerGroupContainersContainerVolumeMountsVolumeMount["MountPath"].isNull())
volumeMountsObject.mountPath = valueJobInfosJobInfoContainerGroupsContainerGroupContainersContainerVolumeMountsVolumeMount["MountPath"].asString();
if(!valueJobInfosJobInfoContainerGroupsContainerGroupContainersContainerVolumeMountsVolumeMount["MountPropagation"].isNull())
volumeMountsObject.mountPropagation = valueJobInfosJobInfoContainerGroupsContainerGroupContainersContainerVolumeMountsVolumeMount["MountPropagation"].asString();
if(!valueJobInfosJobInfoContainerGroupsContainerGroupContainersContainerVolumeMountsVolumeMount["Name"].isNull())
volumeMountsObject.name = valueJobInfosJobInfoContainerGroupsContainerGroupContainersContainerVolumeMountsVolumeMount["Name"].asString();
if(!valueJobInfosJobInfoContainerGroupsContainerGroupContainersContainerVolumeMountsVolumeMount["ReadOnly"].isNull())
volumeMountsObject.readOnly = valueJobInfosJobInfoContainerGroupsContainerGroupContainersContainerVolumeMountsVolumeMount["ReadOnly"].asString() == "true";
if(!valueJobInfosJobInfoContainerGroupsContainerGroupContainersContainerVolumeMountsVolumeMount["SubPath"].isNull())
volumeMountsObject.subPath = valueJobInfosJobInfoContainerGroupsContainerGroupContainersContainerVolumeMountsVolumeMount["SubPath"].asString();
containersObject.volumeMounts.push_back(volumeMountsObject);
}
auto currentStateNode = value["CurrentState"];
if(!currentStateNode["DetailStatus"].isNull())
containersObject.currentState.detailStatus = currentStateNode["DetailStatus"].asString();
if(!currentStateNode["ExitCode"].isNull())
containersObject.currentState.exitCode = std::stol(currentStateNode["ExitCode"].asString());
if(!currentStateNode["FinishTime"].isNull())
containersObject.currentState.finishTime = currentStateNode["FinishTime"].asString();
if(!currentStateNode["Message"].isNull())
containersObject.currentState.message = currentStateNode["Message"].asString();
if(!currentStateNode["Reason"].isNull())
containersObject.currentState.reason = currentStateNode["Reason"].asString();
if(!currentStateNode["Signal"].isNull())
containersObject.currentState.signal = std::stol(currentStateNode["Signal"].asString());
if(!currentStateNode["StartTime"].isNull())
containersObject.currentState.startTime = currentStateNode["StartTime"].asString();
if(!currentStateNode["State"].isNull())
containersObject.currentState.state = currentStateNode["State"].asString();
auto livenessProbeNode = value["LivenessProbe"];
if(!livenessProbeNode["FailureThreshold"].isNull())
containersObject.livenessProbe.failureThreshold = std::stol(livenessProbeNode["FailureThreshold"].asString());
if(!livenessProbeNode["InitialDelaySeconds"].isNull())
containersObject.livenessProbe.initialDelaySeconds = std::stol(livenessProbeNode["InitialDelaySeconds"].asString());
if(!livenessProbeNode["PeriodSeconds"].isNull())
containersObject.livenessProbe.periodSeconds = std::stol(livenessProbeNode["PeriodSeconds"].asString());
if(!livenessProbeNode["SuccessThreshold"].isNull())
containersObject.livenessProbe.successThreshold = std::stol(livenessProbeNode["SuccessThreshold"].asString());
if(!livenessProbeNode["TimeoutSeconds"].isNull())
containersObject.livenessProbe.timeoutSeconds = std::stol(livenessProbeNode["TimeoutSeconds"].asString());
auto httpGetNode = livenessProbeNode["HttpGet"];
if(!httpGetNode["Path"].isNull())
containersObject.livenessProbe.httpGet.path = httpGetNode["Path"].asString();
if(!httpGetNode["Port"].isNull())
containersObject.livenessProbe.httpGet.port = std::stol(httpGetNode["Port"].asString());
if(!httpGetNode["Scheme"].isNull())
containersObject.livenessProbe.httpGet.scheme = httpGetNode["Scheme"].asString();
auto tcpSocketNode = livenessProbeNode["TcpSocket"];
if(!tcpSocketNode["Host"].isNull())
containersObject.livenessProbe.tcpSocket.host = tcpSocketNode["Host"].asString();
if(!tcpSocketNode["Port"].isNull())
containersObject.livenessProbe.tcpSocket.port = std::stol(tcpSocketNode["Port"].asString());
auto allExecs = livenessProbeNode["Execs"]["Exec"];
for (auto value : allExecs)
containersObject.livenessProbe.execs.push_back(value.asString());
auto previousStateNode = value["PreviousState"];
if(!previousStateNode["DetailStatus"].isNull())
containersObject.previousState.detailStatus = previousStateNode["DetailStatus"].asString();
if(!previousStateNode["ExitCode"].isNull())
containersObject.previousState.exitCode = std::stol(previousStateNode["ExitCode"].asString());
if(!previousStateNode["FinishTime"].isNull())
containersObject.previousState.finishTime = previousStateNode["FinishTime"].asString();
if(!previousStateNode["Message"].isNull())
containersObject.previousState.message = previousStateNode["Message"].asString();
if(!previousStateNode["Reason"].isNull())
containersObject.previousState.reason = previousStateNode["Reason"].asString();
if(!previousStateNode["Signal"].isNull())
containersObject.previousState.signal = std::stol(previousStateNode["Signal"].asString());
if(!previousStateNode["StartTime"].isNull())
containersObject.previousState.startTime = previousStateNode["StartTime"].asString();
if(!previousStateNode["State"].isNull())
containersObject.previousState.state = previousStateNode["State"].asString();
auto readinessProbeNode = value["ReadinessProbe"];
if(!readinessProbeNode["FailureThreshold"].isNull())
containersObject.readinessProbe.failureThreshold = std::stol(readinessProbeNode["FailureThreshold"].asString());
if(!readinessProbeNode["InitialDelaySeconds"].isNull())
containersObject.readinessProbe.initialDelaySeconds = std::stol(readinessProbeNode["InitialDelaySeconds"].asString());
if(!readinessProbeNode["PeriodSeconds"].isNull())
containersObject.readinessProbe.periodSeconds = std::stol(readinessProbeNode["PeriodSeconds"].asString());
if(!readinessProbeNode["SuccessThreshold"].isNull())
containersObject.readinessProbe.successThreshold = std::stol(readinessProbeNode["SuccessThreshold"].asString());
if(!readinessProbeNode["TimeoutSeconds"].isNull())
containersObject.readinessProbe.timeoutSeconds = std::stol(readinessProbeNode["TimeoutSeconds"].asString());
auto httpGet2Node = readinessProbeNode["HttpGet"];
if(!httpGet2Node["Path"].isNull())
containersObject.readinessProbe.httpGet2.path = httpGet2Node["Path"].asString();
if(!httpGet2Node["Port"].isNull())
containersObject.readinessProbe.httpGet2.port = std::stol(httpGet2Node["Port"].asString());
if(!httpGet2Node["Scheme"].isNull())
containersObject.readinessProbe.httpGet2.scheme = httpGet2Node["Scheme"].asString();
auto tcpSocket3Node = readinessProbeNode["TcpSocket"];
if(!tcpSocket3Node["Host"].isNull())
containersObject.readinessProbe.tcpSocket3.host = tcpSocket3Node["Host"].asString();
if(!tcpSocket3Node["Port"].isNull())
containersObject.readinessProbe.tcpSocket3.port = std::stol(tcpSocket3Node["Port"].asString());
auto allExecs1 = readinessProbeNode["Execs"]["Exec"];
for (auto value : allExecs1)
containersObject.readinessProbe.execs1.push_back(value.asString());
auto securityContextNode = value["SecurityContext"];
if(!securityContextNode["ReadOnlyRootFilesystem"].isNull())
containersObject.securityContext.readOnlyRootFilesystem = securityContextNode["ReadOnlyRootFilesystem"].asString() == "true";
if(!securityContextNode["RunAsUser"].isNull())
containersObject.securityContext.runAsUser = std::stol(securityContextNode["RunAsUser"].asString());
auto capabilityNode = securityContextNode["Capability"];
auto allAdds = capabilityNode["Adds"]["Add"];
for (auto value : allAdds)
containersObject.securityContext.capability.adds.push_back(value.asString());
auto allArgs = value["Args"]["Arg"];
for (auto value : allArgs)
containersObject.args.push_back(value.asString());
auto allCommands = value["Commands"]["Command"];
for (auto value : allCommands)
containersObject.commands.push_back(value.asString());
containerGroupsObject.containers.push_back(containersObject);
}
auto allVolumesNode = valueJobInfosJobInfoContainerGroupsContainerGroup["Volumes"]["Volume"];
for (auto valueJobInfosJobInfoContainerGroupsContainerGroupVolumesVolume : allVolumesNode)
{
JobInfo::ContainerGroup::Volume volumesObject;
if(!valueJobInfosJobInfoContainerGroupsContainerGroupVolumesVolume["DiskVolumeDiskId"].isNull())
volumesObject.diskVolumeDiskId = valueJobInfosJobInfoContainerGroupsContainerGroupVolumesVolume["DiskVolumeDiskId"].asString();
if(!valueJobInfosJobInfoContainerGroupsContainerGroupVolumesVolume["DiskVolumeFsType"].isNull())
volumesObject.diskVolumeFsType = valueJobInfosJobInfoContainerGroupsContainerGroupVolumesVolume["DiskVolumeFsType"].asString();
if(!valueJobInfosJobInfoContainerGroupsContainerGroupVolumesVolume["EmptyDirVolumeMedium"].isNull())
volumesObject.emptyDirVolumeMedium = valueJobInfosJobInfoContainerGroupsContainerGroupVolumesVolume["EmptyDirVolumeMedium"].asString();
if(!valueJobInfosJobInfoContainerGroupsContainerGroupVolumesVolume["EmptyDirVolumeSizeLimit"].isNull())
volumesObject.emptyDirVolumeSizeLimit = valueJobInfosJobInfoContainerGroupsContainerGroupVolumesVolume["EmptyDirVolumeSizeLimit"].asString();
if(!valueJobInfosJobInfoContainerGroupsContainerGroupVolumesVolume["FlexVolumeDriver"].isNull())
volumesObject.flexVolumeDriver = valueJobInfosJobInfoContainerGroupsContainerGroupVolumesVolume["FlexVolumeDriver"].asString();
if(!valueJobInfosJobInfoContainerGroupsContainerGroupVolumesVolume["FlexVolumeFsType"].isNull())
volumesObject.flexVolumeFsType = valueJobInfosJobInfoContainerGroupsContainerGroupVolumesVolume["FlexVolumeFsType"].asString();
if(!valueJobInfosJobInfoContainerGroupsContainerGroupVolumesVolume["FlexVolumeOptions"].isNull())
volumesObject.flexVolumeOptions = valueJobInfosJobInfoContainerGroupsContainerGroupVolumesVolume["FlexVolumeOptions"].asString();
if(!valueJobInfosJobInfoContainerGroupsContainerGroupVolumesVolume["NFSVolumePath"].isNull())
volumesObject.nFSVolumePath = valueJobInfosJobInfoContainerGroupsContainerGroupVolumesVolume["NFSVolumePath"].asString();
if(!valueJobInfosJobInfoContainerGroupsContainerGroupVolumesVolume["NFSVolumeReadOnly"].isNull())
volumesObject.nFSVolumeReadOnly = valueJobInfosJobInfoContainerGroupsContainerGroupVolumesVolume["NFSVolumeReadOnly"].asString() == "true";
if(!valueJobInfosJobInfoContainerGroupsContainerGroupVolumesVolume["NFSVolumeServer"].isNull())
volumesObject.nFSVolumeServer = valueJobInfosJobInfoContainerGroupsContainerGroupVolumesVolume["NFSVolumeServer"].asString();
if(!valueJobInfosJobInfoContainerGroupsContainerGroupVolumesVolume["Name"].isNull())
volumesObject.name = valueJobInfosJobInfoContainerGroupsContainerGroupVolumesVolume["Name"].asString();
if(!valueJobInfosJobInfoContainerGroupsContainerGroupVolumesVolume["Type"].isNull())
volumesObject.type = valueJobInfosJobInfoContainerGroupsContainerGroupVolumesVolume["Type"].asString();
auto allConfigFileVolumeConfigFileToPathsNode = valueJobInfosJobInfoContainerGroupsContainerGroupVolumesVolume["ConfigFileVolumeConfigFileToPaths"]["ConfigFileVolumeConfigFileToPath"];
for (auto valueJobInfosJobInfoContainerGroupsContainerGroupVolumesVolumeConfigFileVolumeConfigFileToPathsConfigFileVolumeConfigFileToPath : allConfigFileVolumeConfigFileToPathsNode)
{
JobInfo::ContainerGroup::Volume::ConfigFileVolumeConfigFileToPath configFileVolumeConfigFileToPathsObject;
if(!valueJobInfosJobInfoContainerGroupsContainerGroupVolumesVolumeConfigFileVolumeConfigFileToPathsConfigFileVolumeConfigFileToPath["Content"].isNull())
configFileVolumeConfigFileToPathsObject.content = valueJobInfosJobInfoContainerGroupsContainerGroupVolumesVolumeConfigFileVolumeConfigFileToPathsConfigFileVolumeConfigFileToPath["Content"].asString();
if(!valueJobInfosJobInfoContainerGroupsContainerGroupVolumesVolumeConfigFileVolumeConfigFileToPathsConfigFileVolumeConfigFileToPath["Path"].isNull())
configFileVolumeConfigFileToPathsObject.path = valueJobInfosJobInfoContainerGroupsContainerGroupVolumesVolumeConfigFileVolumeConfigFileToPathsConfigFileVolumeConfigFileToPath["Path"].asString();
volumesObject.configFileVolumeConfigFileToPaths.push_back(configFileVolumeConfigFileToPathsObject);
}
containerGroupsObject.volumes.push_back(volumesObject);
}
auto allEventsNode = valueJobInfosJobInfoContainerGroupsContainerGroup["Events"]["Event"];
for (auto valueJobInfosJobInfoContainerGroupsContainerGroupEventsEvent : allEventsNode)
{
JobInfo::ContainerGroup::Event eventsObject;
if(!valueJobInfosJobInfoContainerGroupsContainerGroupEventsEvent["Count"].isNull())
eventsObject.count = std::stoi(valueJobInfosJobInfoContainerGroupsContainerGroupEventsEvent["Count"].asString());
if(!valueJobInfosJobInfoContainerGroupsContainerGroupEventsEvent["FirstTimestamp"].isNull())
eventsObject.firstTimestamp = valueJobInfosJobInfoContainerGroupsContainerGroupEventsEvent["FirstTimestamp"].asString();
if(!valueJobInfosJobInfoContainerGroupsContainerGroupEventsEvent["LastTimestamp"].isNull())
eventsObject.lastTimestamp = valueJobInfosJobInfoContainerGroupsContainerGroupEventsEvent["LastTimestamp"].asString();
if(!valueJobInfosJobInfoContainerGroupsContainerGroupEventsEvent["Message"].isNull())
eventsObject.message = valueJobInfosJobInfoContainerGroupsContainerGroupEventsEvent["Message"].asString();
if(!valueJobInfosJobInfoContainerGroupsContainerGroupEventsEvent["Name"].isNull())
eventsObject.name = valueJobInfosJobInfoContainerGroupsContainerGroupEventsEvent["Name"].asString();
if(!valueJobInfosJobInfoContainerGroupsContainerGroupEventsEvent["Reason"].isNull())
eventsObject.reason = valueJobInfosJobInfoContainerGroupsContainerGroupEventsEvent["Reason"].asString();
if(!valueJobInfosJobInfoContainerGroupsContainerGroupEventsEvent["Type"].isNull())
eventsObject.type = valueJobInfosJobInfoContainerGroupsContainerGroupEventsEvent["Type"].asString();
containerGroupsObject.events.push_back(eventsObject);
}
auto allHostAliasesNode = valueJobInfosJobInfoContainerGroupsContainerGroup["HostAliases"]["HostAlias"];
for (auto valueJobInfosJobInfoContainerGroupsContainerGroupHostAliasesHostAlias : allHostAliasesNode)
{
JobInfo::ContainerGroup::HostAlias hostAliasesObject;
if(!valueJobInfosJobInfoContainerGroupsContainerGroupHostAliasesHostAlias["Ip"].isNull())
hostAliasesObject.ip = valueJobInfosJobInfoContainerGroupsContainerGroupHostAliasesHostAlias["Ip"].asString();
auto allHostnames = value["Hostnames"]["Hostname"];
for (auto value : allHostnames)
hostAliasesObject.hostnames.push_back(value.asString());
containerGroupsObject.hostAliases.push_back(hostAliasesObject);
}
auto allInitContainersNode = valueJobInfosJobInfoContainerGroupsContainerGroup["InitContainers"]["InitContainer"];
for (auto valueJobInfosJobInfoContainerGroupsContainerGroupInitContainersInitContainer : allInitContainersNode)
{
JobInfo::ContainerGroup::InitContainer initContainersObject;
if(!valueJobInfosJobInfoContainerGroupsContainerGroupInitContainersInitContainer["Cpu"].isNull())
initContainersObject.cpu = std::stol(valueJobInfosJobInfoContainerGroupsContainerGroupInitContainersInitContainer["Cpu"].asString());
if(!valueJobInfosJobInfoContainerGroupsContainerGroupInitContainersInitContainer["Gpu"].isNull())
initContainersObject.gpu = std::stol(valueJobInfosJobInfoContainerGroupsContainerGroupInitContainersInitContainer["Gpu"].asString());
if(!valueJobInfosJobInfoContainerGroupsContainerGroupInitContainersInitContainer["Image"].isNull())
initContainersObject.image = valueJobInfosJobInfoContainerGroupsContainerGroupInitContainersInitContainer["Image"].asString();
if(!valueJobInfosJobInfoContainerGroupsContainerGroupInitContainersInitContainer["ImagePullPolicy"].isNull())
initContainersObject.imagePullPolicy = valueJobInfosJobInfoContainerGroupsContainerGroupInitContainersInitContainer["ImagePullPolicy"].asString();
if(!valueJobInfosJobInfoContainerGroupsContainerGroupInitContainersInitContainer["Memory"].isNull())
initContainersObject.memory = std::stol(valueJobInfosJobInfoContainerGroupsContainerGroupInitContainersInitContainer["Memory"].asString());
if(!valueJobInfosJobInfoContainerGroupsContainerGroupInitContainersInitContainer["Name"].isNull())
initContainersObject.name = valueJobInfosJobInfoContainerGroupsContainerGroupInitContainersInitContainer["Name"].asString();
if(!valueJobInfosJobInfoContainerGroupsContainerGroupInitContainersInitContainer["Ready"].isNull())
initContainersObject.ready = valueJobInfosJobInfoContainerGroupsContainerGroupInitContainersInitContainer["Ready"].asString() == "true";
if(!valueJobInfosJobInfoContainerGroupsContainerGroupInitContainersInitContainer["RestartCount"].isNull())
initContainersObject.restartCount = std::stol(valueJobInfosJobInfoContainerGroupsContainerGroupInitContainersInitContainer["RestartCount"].asString());
if(!valueJobInfosJobInfoContainerGroupsContainerGroupInitContainersInitContainer["WorkingDir"].isNull())
initContainersObject.workingDir = valueJobInfosJobInfoContainerGroupsContainerGroupInitContainersInitContainer["WorkingDir"].asString();
auto allEnvironmentVars8Node = valueJobInfosJobInfoContainerGroupsContainerGroupInitContainersInitContainer["EnvironmentVars"]["EnvironmentVar"];
for (auto valueJobInfosJobInfoContainerGroupsContainerGroupInitContainersInitContainerEnvironmentVarsEnvironmentVar : allEnvironmentVars8Node)
{
JobInfo::ContainerGroup::InitContainer::EnvironmentVar11 environmentVars8Object;
if(!valueJobInfosJobInfoContainerGroupsContainerGroupInitContainersInitContainerEnvironmentVarsEnvironmentVar["Key"].isNull())
environmentVars8Object.key = valueJobInfosJobInfoContainerGroupsContainerGroupInitContainersInitContainerEnvironmentVarsEnvironmentVar["Key"].asString();
if(!valueJobInfosJobInfoContainerGroupsContainerGroupInitContainersInitContainerEnvironmentVarsEnvironmentVar["Value"].isNull())
environmentVars8Object.value = valueJobInfosJobInfoContainerGroupsContainerGroupInitContainersInitContainerEnvironmentVarsEnvironmentVar["Value"].asString();
auto valueFrom12Node = value["ValueFrom"];
auto fieldRef13Node = valueFrom12Node["FieldRef"];
if(!fieldRef13Node["FieldPath"].isNull())
environmentVars8Object.valueFrom12.fieldRef13.fieldPath = fieldRef13Node["FieldPath"].asString();
initContainersObject.environmentVars8.push_back(environmentVars8Object);
}
auto allPorts9Node = valueJobInfosJobInfoContainerGroupsContainerGroupInitContainersInitContainer["Ports"]["Port"];
for (auto valueJobInfosJobInfoContainerGroupsContainerGroupInitContainersInitContainerPortsPort : allPorts9Node)
{
JobInfo::ContainerGroup::InitContainer::Port14 ports9Object;
if(!valueJobInfosJobInfoContainerGroupsContainerGroupInitContainersInitContainerPortsPort["Port"].isNull())
ports9Object.port = std::stol(valueJobInfosJobInfoContainerGroupsContainerGroupInitContainersInitContainerPortsPort["Port"].asString());
if(!valueJobInfosJobInfoContainerGroupsContainerGroupInitContainersInitContainerPortsPort["Protocol"].isNull())
ports9Object.protocol = valueJobInfosJobInfoContainerGroupsContainerGroupInitContainersInitContainerPortsPort["Protocol"].asString();
initContainersObject.ports9.push_back(ports9Object);
}
auto allVolumeMounts10Node = valueJobInfosJobInfoContainerGroupsContainerGroupInitContainersInitContainer["VolumeMounts"]["VolumeMount"];
for (auto valueJobInfosJobInfoContainerGroupsContainerGroupInitContainersInitContainerVolumeMountsVolumeMount : allVolumeMounts10Node)
{
JobInfo::ContainerGroup::InitContainer::VolumeMount15 volumeMounts10Object;
if(!valueJobInfosJobInfoContainerGroupsContainerGroupInitContainersInitContainerVolumeMountsVolumeMount["MountPath"].isNull())
volumeMounts10Object.mountPath = valueJobInfosJobInfoContainerGroupsContainerGroupInitContainersInitContainerVolumeMountsVolumeMount["MountPath"].asString();
if(!valueJobInfosJobInfoContainerGroupsContainerGroupInitContainersInitContainerVolumeMountsVolumeMount["MountPropagation"].isNull())
volumeMounts10Object.mountPropagation = valueJobInfosJobInfoContainerGroupsContainerGroupInitContainersInitContainerVolumeMountsVolumeMount["MountPropagation"].asString();
if(!valueJobInfosJobInfoContainerGroupsContainerGroupInitContainersInitContainerVolumeMountsVolumeMount["Name"].isNull())
volumeMounts10Object.name = valueJobInfosJobInfoContainerGroupsContainerGroupInitContainersInitContainerVolumeMountsVolumeMount["Name"].asString();
if(!valueJobInfosJobInfoContainerGroupsContainerGroupInitContainersInitContainerVolumeMountsVolumeMount["ReadOnly"].isNull())
volumeMounts10Object.readOnly = valueJobInfosJobInfoContainerGroupsContainerGroupInitContainersInitContainerVolumeMountsVolumeMount["ReadOnly"].asString() == "true";
initContainersObject.volumeMounts10.push_back(volumeMounts10Object);
}
auto currentState5Node = value["CurrentState"];
if(!currentState5Node["DetailStatus"].isNull())
initContainersObject.currentState5.detailStatus = currentState5Node["DetailStatus"].asString();
if(!currentState5Node["ExitCode"].isNull())
initContainersObject.currentState5.exitCode = std::stol(currentState5Node["ExitCode"].asString());
if(!currentState5Node["FinishTime"].isNull())
initContainersObject.currentState5.finishTime = currentState5Node["FinishTime"].asString();
if(!currentState5Node["Message"].isNull())
initContainersObject.currentState5.message = currentState5Node["Message"].asString();
if(!currentState5Node["Reason"].isNull())
initContainersObject.currentState5.reason = currentState5Node["Reason"].asString();
if(!currentState5Node["Signal"].isNull())
initContainersObject.currentState5.signal = std::stol(currentState5Node["Signal"].asString());
if(!currentState5Node["StartTime"].isNull())
initContainersObject.currentState5.startTime = currentState5Node["StartTime"].asString();
if(!currentState5Node["State"].isNull())
initContainersObject.currentState5.state = currentState5Node["State"].asString();
auto previousState6Node = value["PreviousState"];
if(!previousState6Node["DetailStatus"].isNull())
initContainersObject.previousState6.detailStatus = previousState6Node["DetailStatus"].asString();
if(!previousState6Node["ExitCode"].isNull())
initContainersObject.previousState6.exitCode = std::stol(previousState6Node["ExitCode"].asString());
if(!previousState6Node["FinishTime"].isNull())
initContainersObject.previousState6.finishTime = previousState6Node["FinishTime"].asString();
if(!previousState6Node["Message"].isNull())
initContainersObject.previousState6.message = previousState6Node["Message"].asString();
if(!previousState6Node["Reason"].isNull())
initContainersObject.previousState6.reason = previousState6Node["Reason"].asString();
if(!previousState6Node["Signal"].isNull())
initContainersObject.previousState6.signal = std::stol(previousState6Node["Signal"].asString());
if(!previousState6Node["StartTime"].isNull())
initContainersObject.previousState6.startTime = previousState6Node["StartTime"].asString();
if(!previousState6Node["State"].isNull())
initContainersObject.previousState6.state = previousState6Node["State"].asString();
auto securityContext7Node = value["SecurityContext"];
if(!securityContext7Node["ReadOnlyRootFilesystem"].isNull())
initContainersObject.securityContext7.readOnlyRootFilesystem = securityContext7Node["ReadOnlyRootFilesystem"].asString() == "true";
if(!securityContext7Node["RunAsUser"].isNull())
initContainersObject.securityContext7.runAsUser = std::stol(securityContext7Node["RunAsUser"].asString());
auto capability16Node = securityContext7Node["Capability"];
auto allAdds17 = capability16Node["Adds"]["Add"];
for (auto value : allAdds17)
initContainersObject.securityContext7.capability16.adds17.push_back(value.asString());
auto allArgs4 = value["Args"]["Arg"];
for (auto value : allArgs4)
initContainersObject.args4.push_back(value.asString());
auto allCommand = value["Command"]["Command"];
for (auto value : allCommand)
initContainersObject.command.push_back(value.asString());
containerGroupsObject.initContainers.push_back(initContainersObject);
}
auto allTagsNode = valueJobInfosJobInfoContainerGroupsContainerGroup["Tags"]["Tag"];
for (auto valueJobInfosJobInfoContainerGroupsContainerGroupTagsTag : allTagsNode)
{
JobInfo::ContainerGroup::Tag tagsObject;
if(!valueJobInfosJobInfoContainerGroupsContainerGroupTagsTag["Key"].isNull())
tagsObject.key = valueJobInfosJobInfoContainerGroupsContainerGroupTagsTag["Key"].asString();
if(!valueJobInfosJobInfoContainerGroupsContainerGroupTagsTag["Value"].isNull())
tagsObject.value = valueJobInfosJobInfoContainerGroupsContainerGroupTagsTag["Value"].asString();
containerGroupsObject.tags.push_back(tagsObject);
}
auto dnsConfigNode = value["DnsConfig"];
auto allOptionsNode = dnsConfigNode["Options"]["Option"];
for (auto dnsConfigNodeOptionsOption : allOptionsNode)
{
JobInfo::ContainerGroup::DnsConfig::Option optionObject;
if(!dnsConfigNodeOptionsOption["Name"].isNull())
optionObject.name = dnsConfigNodeOptionsOption["Name"].asString();
if(!dnsConfigNodeOptionsOption["Value"].isNull())
optionObject.value = dnsConfigNodeOptionsOption["Value"].asString();
containerGroupsObject.dnsConfig.options.push_back(optionObject);
}
auto allNameServers = dnsConfigNode["NameServers"]["NameServer"];
for (auto value : allNameServers)
containerGroupsObject.dnsConfig.nameServers.push_back(value.asString());
auto allSearches = dnsConfigNode["Searches"]["Search"];
for (auto value : allSearches)
containerGroupsObject.dnsConfig.searches.push_back(value.asString());
auto eciSecurityContextNode = value["EciSecurityContext"];
auto allSysctlsNode = eciSecurityContextNode["Sysctls"]["Sysctl"];
for (auto eciSecurityContextNodeSysctlsSysctl : allSysctlsNode)
{
JobInfo::ContainerGroup::EciSecurityContext::Sysctl sysctlObject;
if(!eciSecurityContextNodeSysctlsSysctl["Name"].isNull())
sysctlObject.name = eciSecurityContextNodeSysctlsSysctl["Name"].asString();
if(!eciSecurityContextNodeSysctlsSysctl["Value"].isNull())
sysctlObject.value = eciSecurityContextNodeSysctlsSysctl["Value"].asString();
containerGroupsObject.eciSecurityContext.sysctls.push_back(sysctlObject);
}
jobInfosObject.containerGroups.push_back(containerGroupsObject);
}
auto arrayPropertiesNode = value["ArrayProperties"];
if(!arrayPropertiesNode["IndexStart"].isNull())
jobInfosObject.arrayProperties.indexStart = std::stol(arrayPropertiesNode["IndexStart"].asString());
if(!arrayPropertiesNode["IndexEnd"].isNull())
jobInfosObject.arrayProperties.indexEnd = std::stol(arrayPropertiesNode["IndexEnd"].asString());
if(!arrayPropertiesNode["IndexStep"].isNull())
jobInfosObject.arrayProperties.indexStep = std::stol(arrayPropertiesNode["IndexStep"].asString());
jobInfos_.push_back(jobInfosObject);
}
if(!value["TotalCount"].isNull())
totalCount_ = std::stoi(value["TotalCount"].asString());
}
int DescribeServerlessJobsResult::getTotalCount()const
{
return totalCount_;
}
std::vector<DescribeServerlessJobsResult::JobInfo> DescribeServerlessJobsResult::getJobInfos()const
{
return jobInfos_;
}

View File

@@ -1,225 +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/EditJobTemplateRequest.h>
using AlibabaCloud::EHPC::Model::EditJobTemplateRequest;
EditJobTemplateRequest::EditJobTemplateRequest()
: RpcServiceRequest("ehpc", "2018-04-12", "EditJobTemplate") {
setMethod(HttpRequest::Method::Get);
}
EditJobTemplateRequest::~EditJobTemplateRequest() {}
std::string EditJobTemplateRequest::getStderrRedirectPath() const {
return stderrRedirectPath_;
}
void EditJobTemplateRequest::setStderrRedirectPath(const std::string &stderrRedirectPath) {
stderrRedirectPath_ = stderrRedirectPath;
setParameter(std::string("StderrRedirectPath"), stderrRedirectPath);
}
std::string EditJobTemplateRequest::getClockTime() const {
return clockTime_;
}
void EditJobTemplateRequest::setClockTime(const std::string &clockTime) {
clockTime_ = clockTime;
setParameter(std::string("ClockTime"), clockTime);
}
std::string EditJobTemplateRequest::getCommandLine() const {
return commandLine_;
}
void EditJobTemplateRequest::setCommandLine(const std::string &commandLine) {
commandLine_ = commandLine;
setParameter(std::string("CommandLine"), commandLine);
}
std::string EditJobTemplateRequest::getAccessKeyId() const {
return accessKeyId_;
}
void EditJobTemplateRequest::setAccessKeyId(const std::string &accessKeyId) {
accessKeyId_ = accessKeyId;
setParameter(std::string("AccessKeyId"), accessKeyId);
}
std::string EditJobTemplateRequest::getArrayRequest() const {
return arrayRequest_;
}
void EditJobTemplateRequest::setArrayRequest(const std::string &arrayRequest) {
arrayRequest_ = arrayRequest;
setParameter(std::string("ArrayRequest"), arrayRequest);
}
std::string EditJobTemplateRequest::getUnzipCmd() const {
return unzipCmd_;
}
void EditJobTemplateRequest::setUnzipCmd(const std::string &unzipCmd) {
unzipCmd_ = unzipCmd;
setParameter(std::string("UnzipCmd"), unzipCmd);
}
std::string EditJobTemplateRequest::getPackagePath() const {
return packagePath_;
}
void EditJobTemplateRequest::setPackagePath(const std::string &packagePath) {
packagePath_ = packagePath;
setParameter(std::string("PackagePath"), packagePath);
}
std::string EditJobTemplateRequest::getMem() const {
return mem_;
}
void EditJobTemplateRequest::setMem(const std::string &mem) {
mem_ = mem;
setParameter(std::string("Mem"), mem);
}
std::string EditJobTemplateRequest::getStdoutRedirectPath() const {
return stdoutRedirectPath_;
}
void EditJobTemplateRequest::setStdoutRedirectPath(const std::string &stdoutRedirectPath) {
stdoutRedirectPath_ = stdoutRedirectPath;
setParameter(std::string("StdoutRedirectPath"), stdoutRedirectPath);
}
std::string EditJobTemplateRequest::getVariables() const {
return variables_;
}
void EditJobTemplateRequest::setVariables(const std::string &variables) {
variables_ = variables;
setParameter(std::string("Variables"), variables);
}
std::string EditJobTemplateRequest::getRunasUser() const {
return runasUser_;
}
void EditJobTemplateRequest::setRunasUser(const std::string &runasUser) {
runasUser_ = runasUser;
setParameter(std::string("RunasUser"), runasUser);
}
bool EditJobTemplateRequest::getReRunable() const {
return reRunable_;
}
void EditJobTemplateRequest::setReRunable(bool reRunable) {
reRunable_ = reRunable;
setParameter(std::string("ReRunable"), reRunable ? "true" : "false");
}
int EditJobTemplateRequest::getThread() const {
return thread_;
}
void EditJobTemplateRequest::setThread(int thread) {
thread_ = thread;
setParameter(std::string("Thread"), std::to_string(thread));
}
std::string EditJobTemplateRequest::getTemplateId() const {
return templateId_;
}
void EditJobTemplateRequest::setTemplateId(const std::string &templateId) {
templateId_ = templateId;
setParameter(std::string("TemplateId"), templateId);
}
int EditJobTemplateRequest::getPriority() const {
return priority_;
}
void EditJobTemplateRequest::setPriority(int priority) {
priority_ = priority;
setParameter(std::string("Priority"), std::to_string(priority));
}
int EditJobTemplateRequest::getGpu() const {
return gpu_;
}
void EditJobTemplateRequest::setGpu(int gpu) {
gpu_ = gpu;
setParameter(std::string("Gpu"), std::to_string(gpu));
}
bool EditJobTemplateRequest::getWithUnzipCmd() const {
return withUnzipCmd_;
}
void EditJobTemplateRequest::setWithUnzipCmd(bool withUnzipCmd) {
withUnzipCmd_ = withUnzipCmd;
setParameter(std::string("WithUnzipCmd"), withUnzipCmd ? "true" : "false");
}
int EditJobTemplateRequest::getNode() const {
return node_;
}
void EditJobTemplateRequest::setNode(int node) {
node_ = node;
setParameter(std::string("Node"), std::to_string(node));
}
int EditJobTemplateRequest::getTask() const {
return task_;
}
void EditJobTemplateRequest::setTask(int task) {
task_ = task;
setParameter(std::string("Task"), std::to_string(task));
}
std::string EditJobTemplateRequest::getInputFileUrl() const {
return inputFileUrl_;
}
void EditJobTemplateRequest::setInputFileUrl(const std::string &inputFileUrl) {
inputFileUrl_ = inputFileUrl;
setParameter(std::string("InputFileUrl"), inputFileUrl);
}
std::string EditJobTemplateRequest::getName() const {
return name_;
}
void EditJobTemplateRequest::setName(const std::string &name) {
name_ = name;
setParameter(std::string("Name"), name);
}
std::string EditJobTemplateRequest::getQueue() const {
return queue_;
}
void EditJobTemplateRequest::setQueue(const std::string &queue) {
queue_ = queue;
setParameter(std::string("Queue"), queue);
}

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/EditJobTemplateResult.h>
#include <json/json.h>
using namespace AlibabaCloud::EHPC;
using namespace AlibabaCloud::EHPC::Model;
EditJobTemplateResult::EditJobTemplateResult() :
ServiceResult()
{}
EditJobTemplateResult::EditJobTemplateResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
EditJobTemplateResult::~EditJobTemplateResult()
{}
void EditJobTemplateResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
if(!value["TemplateId"].isNull())
templateId_ = value["TemplateId"].asString();
}
std::string EditJobTemplateResult::getTemplateId()const
{
return templateId_;
}

View File

@@ -1,117 +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/GetAccountingReportRequest.h>
using AlibabaCloud::EHPC::Model::GetAccountingReportRequest;
GetAccountingReportRequest::GetAccountingReportRequest()
: RpcServiceRequest("ehpc", "2018-04-12", "GetAccountingReport") {
setMethod(HttpRequest::Method::Get);
}
GetAccountingReportRequest::~GetAccountingReportRequest() {}
std::string GetAccountingReportRequest::getReportType() const {
return reportType_;
}
void GetAccountingReportRequest::setReportType(const std::string &reportType) {
reportType_ = reportType;
setParameter(std::string("ReportType"), reportType);
}
int GetAccountingReportRequest::getEndTime() const {
return endTime_;
}
void GetAccountingReportRequest::setEndTime(int endTime) {
endTime_ = endTime;
setParameter(std::string("EndTime"), std::to_string(endTime));
}
std::string GetAccountingReportRequest::getFilterValue() const {
return filterValue_;
}
void GetAccountingReportRequest::setFilterValue(const std::string &filterValue) {
filterValue_ = filterValue;
setParameter(std::string("FilterValue"), filterValue);
}
std::string GetAccountingReportRequest::getDim() const {
return dim_;
}
void GetAccountingReportRequest::setDim(const std::string &dim) {
dim_ = dim;
setParameter(std::string("Dim"), dim);
}
std::string GetAccountingReportRequest::getClusterId() const {
return clusterId_;
}
void GetAccountingReportRequest::setClusterId(const std::string &clusterId) {
clusterId_ = clusterId;
setParameter(std::string("ClusterId"), clusterId);
}
int GetAccountingReportRequest::getStartTime() const {
return startTime_;
}
void GetAccountingReportRequest::setStartTime(int startTime) {
startTime_ = startTime;
setParameter(std::string("StartTime"), std::to_string(startTime));
}
int GetAccountingReportRequest::getPageNumber() const {
return pageNumber_;
}
void GetAccountingReportRequest::setPageNumber(int pageNumber) {
pageNumber_ = pageNumber;
setParameter(std::string("PageNumber"), std::to_string(pageNumber));
}
std::string GetAccountingReportRequest::getAccessKeyId() const {
return accessKeyId_;
}
void GetAccountingReportRequest::setAccessKeyId(const std::string &accessKeyId) {
accessKeyId_ = accessKeyId;
setParameter(std::string("AccessKeyId"), accessKeyId);
}
std::string GetAccountingReportRequest::getJobId() const {
return jobId_;
}
void GetAccountingReportRequest::setJobId(const std::string &jobId) {
jobId_ = jobId;
setParameter(std::string("JobId"), jobId);
}
int GetAccountingReportRequest::getPageSize() const {
return pageSize_;
}
void GetAccountingReportRequest::setPageSize(int pageSize) {
pageSize_ = pageSize;
setParameter(std::string("PageSize"), std::to_string(pageSize));
}

View File

@@ -1,87 +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/GetAccountingReportResult.h>
#include <json/json.h>
using namespace AlibabaCloud::EHPC;
using namespace AlibabaCloud::EHPC::Model;
GetAccountingReportResult::GetAccountingReportResult() :
ServiceResult()
{}
GetAccountingReportResult::GetAccountingReportResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
GetAccountingReportResult::~GetAccountingReportResult()
{}
void GetAccountingReportResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
auto allData = value["Data"]["Data"];
for (const auto &item : allData)
data_.push_back(item.asString());
if(!value["TotalCoreTime"].isNull())
totalCoreTime_ = std::stoi(value["TotalCoreTime"].asString());
if(!value["Metrics"].isNull())
metrics_ = value["Metrics"].asString();
if(!value["PageSize"].isNull())
pageSize_ = std::stoi(value["PageSize"].asString());
if(!value["PageNumber"].isNull())
pageNumber_ = std::stoi(value["PageNumber"].asString());
if(!value["TotalCount"].isNull())
totalCount_ = std::stoi(value["TotalCount"].asString());
}
std::string GetAccountingReportResult::getMetrics()const
{
return metrics_;
}
int GetAccountingReportResult::getTotalCount()const
{
return totalCount_;
}
int GetAccountingReportResult::getPageSize()const
{
return pageSize_;
}
int GetAccountingReportResult::getPageNumber()const
{
return pageNumber_;
}
std::vector<std::string> GetAccountingReportResult::getData()const
{
return data_;
}
int GetAccountingReportResult::getTotalCoreTime()const
{
return totalCoreTime_;
}

View File

@@ -1,45 +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/GetAutoScaleConfigRequest.h>
using AlibabaCloud::EHPC::Model::GetAutoScaleConfigRequest;
GetAutoScaleConfigRequest::GetAutoScaleConfigRequest()
: RpcServiceRequest("ehpc", "2018-04-12", "GetAutoScaleConfig") {
setMethod(HttpRequest::Method::Get);
}
GetAutoScaleConfigRequest::~GetAutoScaleConfigRequest() {}
std::string GetAutoScaleConfigRequest::getClusterId() const {
return clusterId_;
}
void GetAutoScaleConfigRequest::setClusterId(const std::string &clusterId) {
clusterId_ = clusterId;
setParameter(std::string("ClusterId"), clusterId);
}
std::string GetAutoScaleConfigRequest::getAccessKeyId() const {
return accessKeyId_;
}
void GetAutoScaleConfigRequest::setAccessKeyId(const std::string &accessKeyId) {
accessKeyId_ = accessKeyId;
setParameter(std::string("AccessKeyId"), accessKeyId);
}

View File

@@ -1,259 +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/GetAutoScaleConfigResult.h>
#include <json/json.h>
using namespace AlibabaCloud::EHPC;
using namespace AlibabaCloud::EHPC::Model;
GetAutoScaleConfigResult::GetAutoScaleConfigResult() :
ServiceResult()
{}
GetAutoScaleConfigResult::GetAutoScaleConfigResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
GetAutoScaleConfigResult::~GetAutoScaleConfigResult()
{}
void GetAutoScaleConfigResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
auto allQueuesNode = value["Queues"]["QueueInfo"];
for (auto valueQueuesQueueInfo : allQueuesNode)
{
QueueInfo queuesObject;
if(!valueQueuesQueueInfo["QueueImageId"].isNull())
queuesObject.queueImageId = valueQueuesQueueInfo["QueueImageId"].asString();
if(!valueQueuesQueueInfo["SystemDiskCategory"].isNull())
queuesObject.systemDiskCategory = valueQueuesQueueInfo["SystemDiskCategory"].asString();
if(!valueQueuesQueueInfo["InstanceType"].isNull())
queuesObject.instanceType = valueQueuesQueueInfo["InstanceType"].asString();
if(!valueQueuesQueueInfo["HostNameSuffix"].isNull())
queuesObject.hostNameSuffix = valueQueuesQueueInfo["HostNameSuffix"].asString();
if(!valueQueuesQueueInfo["SpotStrategy"].isNull())
queuesObject.spotStrategy = valueQueuesQueueInfo["SpotStrategy"].asString();
if(!valueQueuesQueueInfo["MinNodesInQueue"].isNull())
queuesObject.minNodesInQueue = std::stoi(valueQueuesQueueInfo["MinNodesInQueue"].asString());
if(!valueQueuesQueueInfo["HostNamePrefix"].isNull())
queuesObject.hostNamePrefix = valueQueuesQueueInfo["HostNamePrefix"].asString();
if(!valueQueuesQueueInfo["SystemDiskSize"].isNull())
queuesObject.systemDiskSize = std::stoi(valueQueuesQueueInfo["SystemDiskSize"].asString());
if(!valueQueuesQueueInfo["MaxNodesInQueue"].isNull())
queuesObject.maxNodesInQueue = std::stoi(valueQueuesQueueInfo["MaxNodesInQueue"].asString());
if(!valueQueuesQueueInfo["EnableAutoShrink"].isNull())
queuesObject.enableAutoShrink = valueQueuesQueueInfo["EnableAutoShrink"].asString() == "true";
if(!valueQueuesQueueInfo["QueueName"].isNull())
queuesObject.queueName = valueQueuesQueueInfo["QueueName"].asString();
if(!valueQueuesQueueInfo["EnableAutoGrow"].isNull())
queuesObject.enableAutoGrow = valueQueuesQueueInfo["EnableAutoGrow"].asString() == "true";
if(!valueQueuesQueueInfo["SystemDiskLevel"].isNull())
queuesObject.systemDiskLevel = valueQueuesQueueInfo["SystemDiskLevel"].asString();
if(!valueQueuesQueueInfo["ResourceGroupId"].isNull())
queuesObject.resourceGroupId = valueQueuesQueueInfo["ResourceGroupId"].asString();
if(!valueQueuesQueueInfo["SpotPriceLimit"].isNull())
queuesObject.spotPriceLimit = std::stof(valueQueuesQueueInfo["SpotPriceLimit"].asString());
if(!valueQueuesQueueInfo["MaxNodesPerCycle"].isNull())
queuesObject.maxNodesPerCycle = std::stol(valueQueuesQueueInfo["MaxNodesPerCycle"].asString());
if(!valueQueuesQueueInfo["MinNodesPerCycle"].isNull())
queuesObject.minNodesPerCycle = std::stol(valueQueuesQueueInfo["MinNodesPerCycle"].asString());
if(!valueQueuesQueueInfo["AutoMinNodesPerCycle"].isNull())
queuesObject.autoMinNodesPerCycle = valueQueuesQueueInfo["AutoMinNodesPerCycle"].asString() == "true";
if(!valueQueuesQueueInfo["SortedByInventory"].isNull())
queuesObject.sortedByInventory = valueQueuesQueueInfo["SortedByInventory"].asString() == "true";
auto allInstanceTypesNode = valueQueuesQueueInfo["InstanceTypes"]["InstanceTypeInfo"];
for (auto valueQueuesQueueInfoInstanceTypesInstanceTypeInfo : allInstanceTypesNode)
{
QueueInfo::InstanceTypeInfo instanceTypesObject;
if(!valueQueuesQueueInfoInstanceTypesInstanceTypeInfo["HostNamePrefix"].isNull())
instanceTypesObject.hostNamePrefix = valueQueuesQueueInfoInstanceTypesInstanceTypeInfo["HostNamePrefix"].asString();
if(!valueQueuesQueueInfoInstanceTypesInstanceTypeInfo["VSwitchId"].isNull())
instanceTypesObject.vSwitchId = valueQueuesQueueInfoInstanceTypesInstanceTypeInfo["VSwitchId"].asString();
if(!valueQueuesQueueInfoInstanceTypesInstanceTypeInfo["ZoneId"].isNull())
instanceTypesObject.zoneId = valueQueuesQueueInfoInstanceTypesInstanceTypeInfo["ZoneId"].asString();
if(!valueQueuesQueueInfoInstanceTypesInstanceTypeInfo["SpotPriceLimit"].isNull())
instanceTypesObject.spotPriceLimit = std::stof(valueQueuesQueueInfoInstanceTypesInstanceTypeInfo["SpotPriceLimit"].asString());
if(!valueQueuesQueueInfoInstanceTypesInstanceTypeInfo["InstanceType"].isNull())
instanceTypesObject.instanceType = valueQueuesQueueInfoInstanceTypesInstanceTypeInfo["InstanceType"].asString();
if(!valueQueuesQueueInfoInstanceTypesInstanceTypeInfo["SpotStrategy"].isNull())
instanceTypesObject.spotStrategy = valueQueuesQueueInfoInstanceTypesInstanceTypeInfo["SpotStrategy"].asString();
if(!valueQueuesQueueInfoInstanceTypesInstanceTypeInfo["SpotDuration"].isNull())
instanceTypesObject.spotDuration = std::stoi(valueQueuesQueueInfoInstanceTypesInstanceTypeInfo["SpotDuration"].asString());
if(!valueQueuesQueueInfoInstanceTypesInstanceTypeInfo["SpotInterruptionBehavior"].isNull())
instanceTypesObject.spotInterruptionBehavior = valueQueuesQueueInfoInstanceTypesInstanceTypeInfo["SpotInterruptionBehavior"].asString();
queuesObject.instanceTypes.push_back(instanceTypesObject);
}
auto allDataDisksNode = valueQueuesQueueInfo["DataDisks"]["DataDisksInfo"];
for (auto valueQueuesQueueInfoDataDisksDataDisksInfo : allDataDisksNode)
{
QueueInfo::DataDisksInfo dataDisksObject;
if(!valueQueuesQueueInfoDataDisksDataDisksInfo["DataDiskCategory"].isNull())
dataDisksObject.dataDiskCategory = valueQueuesQueueInfoDataDisksDataDisksInfo["DataDiskCategory"].asString();
if(!valueQueuesQueueInfoDataDisksDataDisksInfo["DataDiskSize"].isNull())
dataDisksObject.dataDiskSize = std::stoi(valueQueuesQueueInfoDataDisksDataDisksInfo["DataDiskSize"].asString());
if(!valueQueuesQueueInfoDataDisksDataDisksInfo["DataDiskDeleteWithInstance"].isNull())
dataDisksObject.dataDiskDeleteWithInstance = valueQueuesQueueInfoDataDisksDataDisksInfo["DataDiskDeleteWithInstance"].asString() == "true";
if(!valueQueuesQueueInfoDataDisksDataDisksInfo["DataDiskPerformanceLevel"].isNull())
dataDisksObject.dataDiskPerformanceLevel = valueQueuesQueueInfoDataDisksDataDisksInfo["DataDiskPerformanceLevel"].asString();
if(!valueQueuesQueueInfoDataDisksDataDisksInfo["DataDiskEncrypted"].isNull())
dataDisksObject.dataDiskEncrypted = valueQueuesQueueInfoDataDisksDataDisksInfo["DataDiskEncrypted"].asString() == "true";
if(!valueQueuesQueueInfoDataDisksDataDisksInfo["DataDiskKMSKeyId"].isNull())
dataDisksObject.dataDiskKMSKeyId = valueQueuesQueueInfoDataDisksDataDisksInfo["DataDiskKMSKeyId"].asString();
queuesObject.dataDisks.push_back(dataDisksObject);
}
queues_.push_back(queuesObject);
}
if(!value["MaxNodesInCluster"].isNull())
maxNodesInCluster_ = std::stoi(value["MaxNodesInCluster"].asString());
if(!value["GrowTimeoutInMinutes"].isNull())
growTimeoutInMinutes_ = std::stoi(value["GrowTimeoutInMinutes"].asString());
if(!value["SpotStrategy"].isNull())
spotStrategy_ = value["SpotStrategy"].asString();
if(!value["EnableAutoShrink"].isNull())
enableAutoShrink_ = value["EnableAutoShrink"].asString() == "true";
if(!value["EnableAutoGrow"].isNull())
enableAutoGrow_ = value["EnableAutoGrow"].asString() == "true";
if(!value["ClusterType"].isNull())
clusterType_ = value["ClusterType"].asString();
if(!value["ExcludeNodes"].isNull())
excludeNodes_ = value["ExcludeNodes"].asString();
if(!value["ShrinkIntervalInMinutes"].isNull())
shrinkIntervalInMinutes_ = std::stoi(value["ShrinkIntervalInMinutes"].asString());
if(!value["GrowIntervalInMinutes"].isNull())
growIntervalInMinutes_ = std::stoi(value["GrowIntervalInMinutes"].asString());
if(!value["SpotPriceLimit"].isNull())
spotPriceLimit_ = std::stof(value["SpotPriceLimit"].asString());
if(!value["ExtraNodesGrowRatio"].isNull())
extraNodesGrowRatio_ = std::stoi(value["ExtraNodesGrowRatio"].asString());
if(!value["ShrinkIdleTimes"].isNull())
shrinkIdleTimes_ = std::stoi(value["ShrinkIdleTimes"].asString());
if(!value["ImageId"].isNull())
imageId_ = value["ImageId"].asString();
if(!value["GrowRatio"].isNull())
growRatio_ = std::stoi(value["GrowRatio"].asString());
if(!value["ClusterId"].isNull())
clusterId_ = value["ClusterId"].asString();
if(!value["Uid"].isNull())
uid_ = value["Uid"].asString();
if(!value["ComputeEnableHt"].isNull())
computeEnableHt_ = value["ComputeEnableHt"].asString() == "true";
if(!value["DnsConfig"].isNull())
dnsConfig_ = value["DnsConfig"].asString();
}
int GetAutoScaleConfigResult::getExtraNodesGrowRatio()const
{
return extraNodesGrowRatio_;
}
bool GetAutoScaleConfigResult::getEnableAutoGrow()const
{
return enableAutoGrow_;
}
bool GetAutoScaleConfigResult::getComputeEnableHt()const
{
return computeEnableHt_;
}
std::string GetAutoScaleConfigResult::getClusterId()const
{
return clusterId_;
}
int GetAutoScaleConfigResult::getMaxNodesInCluster()const
{
return maxNodesInCluster_;
}
int GetAutoScaleConfigResult::getShrinkIdleTimes()const
{
return shrinkIdleTimes_;
}
bool GetAutoScaleConfigResult::getEnableAutoShrink()const
{
return enableAutoShrink_;
}
std::string GetAutoScaleConfigResult::getClusterType()const
{
return clusterType_;
}
int GetAutoScaleConfigResult::getGrowRatio()const
{
return growRatio_;
}
int GetAutoScaleConfigResult::getGrowIntervalInMinutes()const
{
return growIntervalInMinutes_;
}
std::string GetAutoScaleConfigResult::getUid()const
{
return uid_;
}
int GetAutoScaleConfigResult::getGrowTimeoutInMinutes()const
{
return growTimeoutInMinutes_;
}
std::string GetAutoScaleConfigResult::getDnsConfig()const
{
return dnsConfig_;
}
std::string GetAutoScaleConfigResult::getImageId()const
{
return imageId_;
}
int GetAutoScaleConfigResult::getShrinkIntervalInMinutes()const
{
return shrinkIntervalInMinutes_;
}
float GetAutoScaleConfigResult::getSpotPriceLimit()const
{
return spotPriceLimit_;
}
std::vector<GetAutoScaleConfigResult::QueueInfo> GetAutoScaleConfigResult::getQueues()const
{
return queues_;
}
std::string GetAutoScaleConfigResult::getExcludeNodes()const
{
return excludeNodes_;
}
std::string GetAutoScaleConfigResult::getSpotStrategy()const
{
return spotStrategy_;
}

View File

@@ -1,117 +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/GetCloudMetricLogsRequest.h>
using AlibabaCloud::EHPC::Model::GetCloudMetricLogsRequest;
GetCloudMetricLogsRequest::GetCloudMetricLogsRequest()
: RpcServiceRequest("ehpc", "2018-04-12", "GetCloudMetricLogs") {
setMethod(HttpRequest::Method::Get);
}
GetCloudMetricLogsRequest::~GetCloudMetricLogsRequest() {}
std::string GetCloudMetricLogsRequest::getMetricScope() const {
return metricScope_;
}
void GetCloudMetricLogsRequest::setMetricScope(const std::string &metricScope) {
metricScope_ = metricScope;
setParameter(std::string("MetricScope"), metricScope);
}
std::string GetCloudMetricLogsRequest::getClusterId() const {
return clusterId_;
}
void GetCloudMetricLogsRequest::setClusterId(const std::string &clusterId) {
clusterId_ = clusterId;
setParameter(std::string("ClusterId"), clusterId);
}
int GetCloudMetricLogsRequest::getAggregationInterval() const {
return aggregationInterval_;
}
void GetCloudMetricLogsRequest::setAggregationInterval(int aggregationInterval) {
aggregationInterval_ = aggregationInterval;
setParameter(std::string("AggregationInterval"), std::to_string(aggregationInterval));
}
bool GetCloudMetricLogsRequest::getReverse() const {
return reverse_;
}
void GetCloudMetricLogsRequest::setReverse(bool reverse) {
reverse_ = reverse;
setParameter(std::string("Reverse"), reverse ? "true" : "false");
}
std::string GetCloudMetricLogsRequest::getAccessKeyId() const {
return accessKeyId_;
}
void GetCloudMetricLogsRequest::setAccessKeyId(const std::string &accessKeyId) {
accessKeyId_ = accessKeyId;
setParameter(std::string("AccessKeyId"), accessKeyId);
}
std::string GetCloudMetricLogsRequest::getAggregationType() const {
return aggregationType_;
}
void GetCloudMetricLogsRequest::setAggregationType(const std::string &aggregationType) {
aggregationType_ = aggregationType;
setParameter(std::string("AggregationType"), aggregationType);
}
std::string GetCloudMetricLogsRequest::getFilter() const {
return filter_;
}
void GetCloudMetricLogsRequest::setFilter(const std::string &filter) {
filter_ = filter;
setParameter(std::string("Filter"), filter);
}
std::string GetCloudMetricLogsRequest::getMetricCategories() const {
return metricCategories_;
}
void GetCloudMetricLogsRequest::setMetricCategories(const std::string &metricCategories) {
metricCategories_ = metricCategories;
setParameter(std::string("MetricCategories"), metricCategories);
}
int GetCloudMetricLogsRequest::getFrom() const {
return from_;
}
void GetCloudMetricLogsRequest::setFrom(int from) {
from_ = from;
setParameter(std::string("From"), std::to_string(from));
}
int GetCloudMetricLogsRequest::getTo() const {
return to_;
}
void GetCloudMetricLogsRequest::setTo(int to) {
to_ = to;
setParameter(std::string("To"), std::to_string(to));
}

View File

@@ -1,67 +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/GetCloudMetricLogsResult.h>
#include <json/json.h>
using namespace AlibabaCloud::EHPC;
using namespace AlibabaCloud::EHPC::Model;
GetCloudMetricLogsResult::GetCloudMetricLogsResult() :
ServiceResult()
{}
GetCloudMetricLogsResult::GetCloudMetricLogsResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
GetCloudMetricLogsResult::~GetCloudMetricLogsResult()
{}
void GetCloudMetricLogsResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
auto allMetricLogsNode = value["MetricLogs"]["MetricLog"];
for (auto valueMetricLogsMetricLog : allMetricLogsNode)
{
MetricLog metricLogsObject;
if(!valueMetricLogsMetricLog["Time"].isNull())
metricLogsObject.time = std::stoi(valueMetricLogsMetricLog["Time"].asString());
if(!valueMetricLogsMetricLog["DiskDevice"].isNull())
metricLogsObject.diskDevice = valueMetricLogsMetricLog["DiskDevice"].asString();
if(!valueMetricLogsMetricLog["NetworkInterface"].isNull())
metricLogsObject.networkInterface = valueMetricLogsMetricLog["NetworkInterface"].asString();
if(!valueMetricLogsMetricLog["MetricData"].isNull())
metricLogsObject.metricData = valueMetricLogsMetricLog["MetricData"].asString();
if(!valueMetricLogsMetricLog["Hostname"].isNull())
metricLogsObject.hostname = valueMetricLogsMetricLog["Hostname"].asString();
if(!valueMetricLogsMetricLog["InstanceId"].isNull())
metricLogsObject.instanceId = valueMetricLogsMetricLog["InstanceId"].asString();
metricLogs_.push_back(metricLogsObject);
}
}
std::vector<GetCloudMetricLogsResult::MetricLog> GetCloudMetricLogsResult::getMetricLogs()const
{
return metricLogs_;
}

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.
*/
#include <alibabacloud/ehpc/model/GetCloudMetricProfilingRequest.h>
using AlibabaCloud::EHPC::Model::GetCloudMetricProfilingRequest;
GetCloudMetricProfilingRequest::GetCloudMetricProfilingRequest()
: RpcServiceRequest("ehpc", "2018-04-12", "GetCloudMetricProfiling") {
setMethod(HttpRequest::Method::Get);
}
GetCloudMetricProfilingRequest::~GetCloudMetricProfilingRequest() {}
std::string GetCloudMetricProfilingRequest::getClusterId() const {
return clusterId_;
}
void GetCloudMetricProfilingRequest::setClusterId(const std::string &clusterId) {
clusterId_ = clusterId;
setParameter(std::string("ClusterId"), clusterId);
}
std::string GetCloudMetricProfilingRequest::getAccessKeyId() const {
return accessKeyId_;
}
void GetCloudMetricProfilingRequest::setAccessKeyId(const std::string &accessKeyId) {
accessKeyId_ = accessKeyId;
setParameter(std::string("AccessKeyId"), accessKeyId);
}
std::string GetCloudMetricProfilingRequest::getRegionId() const {
return regionId_;
}
void GetCloudMetricProfilingRequest::setRegionId(const std::string &regionId) {
regionId_ = regionId;
setParameter(std::string("RegionId"), regionId);
}
std::string GetCloudMetricProfilingRequest::getProfilingId() const {
return profilingId_;
}
void GetCloudMetricProfilingRequest::setProfilingId(const std::string &profilingId) {
profilingId_ = profilingId;
setParameter(std::string("ProfilingId"), profilingId);
}

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.
*/
#include <alibabacloud/ehpc/model/GetCloudMetricProfilingResult.h>
#include <json/json.h>
using namespace AlibabaCloud::EHPC;
using namespace AlibabaCloud::EHPC::Model;
GetCloudMetricProfilingResult::GetCloudMetricProfilingResult() :
ServiceResult()
{}
GetCloudMetricProfilingResult::GetCloudMetricProfilingResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
GetCloudMetricProfilingResult::~GetCloudMetricProfilingResult()
{}
void GetCloudMetricProfilingResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
auto allSvgUrlsNode = value["SvgUrls"]["SvgInfo"];
for (auto valueSvgUrlsSvgInfo : allSvgUrlsNode)
{
SvgInfo svgUrlsObject;
if(!valueSvgUrlsSvgInfo["Type"].isNull())
svgUrlsObject.type = valueSvgUrlsSvgInfo["Type"].asString();
if(!valueSvgUrlsSvgInfo["Url"].isNull())
svgUrlsObject.url = valueSvgUrlsSvgInfo["Url"].asString();
if(!valueSvgUrlsSvgInfo["Name"].isNull())
svgUrlsObject.name = valueSvgUrlsSvgInfo["Name"].asString();
if(!valueSvgUrlsSvgInfo["Size"].isNull())
svgUrlsObject.size = std::stoi(valueSvgUrlsSvgInfo["Size"].asString());
svgUrls_.push_back(svgUrlsObject);
}
}
std::vector<GetCloudMetricProfilingResult::SvgInfo> GetCloudMetricProfilingResult::getSvgUrls()const
{
return svgUrls_;
}

View File

@@ -1,45 +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/GetClusterVolumesRequest.h>
using AlibabaCloud::EHPC::Model::GetClusterVolumesRequest;
GetClusterVolumesRequest::GetClusterVolumesRequest()
: RpcServiceRequest("ehpc", "2018-04-12", "GetClusterVolumes") {
setMethod(HttpRequest::Method::Get);
}
GetClusterVolumesRequest::~GetClusterVolumesRequest() {}
std::string GetClusterVolumesRequest::getClusterId() const {
return clusterId_;
}
void GetClusterVolumesRequest::setClusterId(const std::string &clusterId) {
clusterId_ = clusterId;
setParameter(std::string("ClusterId"), clusterId);
}
std::string GetClusterVolumesRequest::getAccessKeyId() const {
return accessKeyId_;
}
void GetClusterVolumesRequest::setAccessKeyId(const std::string &accessKeyId) {
accessKeyId_ = accessKeyId;
setParameter(std::string("AccessKeyId"), accessKeyId);
}

Some files were not shown because too many files have changed in this diff Show More