|
|
@@ -159,180 +159,180 @@ EHPCClient::ListUsersOutcomeCallable EHPCClient::listUsersCallable(const ListUse
|
|
|
return task->get_future();
|
|
|
}
|
|
|
|
|
|
-EHPCClient::UpgradeClientOutcome EHPCClient::upgradeClient(const UpgradeClientRequest &request) const
|
|
|
+EHPCClient::StopNodesOutcome EHPCClient::stopNodes(const StopNodesRequest &request) const
|
|
|
{
|
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
|
if (!endpointOutcome.isSuccess())
|
|
|
- return UpgradeClientOutcome(endpointOutcome.error());
|
|
|
+ return StopNodesOutcome(endpointOutcome.error());
|
|
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
|
|
if (outcome.isSuccess())
|
|
|
- return UpgradeClientOutcome(UpgradeClientResult(outcome.result()));
|
|
|
+ return StopNodesOutcome(StopNodesResult(outcome.result()));
|
|
|
else
|
|
|
- return UpgradeClientOutcome(outcome.error());
|
|
|
+ return StopNodesOutcome(outcome.error());
|
|
|
}
|
|
|
|
|
|
-void EHPCClient::upgradeClientAsync(const UpgradeClientRequest& request, const UpgradeClientAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
|
+void EHPCClient::stopNodesAsync(const StopNodesRequest& request, const StopNodesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
|
{
|
|
|
auto fn = [this, request, handler, context]()
|
|
|
{
|
|
|
- handler(this, request, upgradeClient(request), context);
|
|
|
+ handler(this, request, stopNodes(request), context);
|
|
|
};
|
|
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
|
}
|
|
|
|
|
|
-EHPCClient::UpgradeClientOutcomeCallable EHPCClient::upgradeClientCallable(const UpgradeClientRequest &request) const
|
|
|
+EHPCClient::StopNodesOutcomeCallable EHPCClient::stopNodesCallable(const StopNodesRequest &request) const
|
|
|
{
|
|
|
- auto task = std::make_shared<std::packaged_task<UpgradeClientOutcome()>>(
|
|
|
+ auto task = std::make_shared<std::packaged_task<StopNodesOutcome()>>(
|
|
|
[this, request]()
|
|
|
{
|
|
|
- return this->upgradeClient(request);
|
|
|
+ return this->stopNodes(request);
|
|
|
});
|
|
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
|
return task->get_future();
|
|
|
}
|
|
|
|
|
|
-EHPCClient::StopNodesOutcome EHPCClient::stopNodes(const StopNodesRequest &request) const
|
|
|
+EHPCClient::PullImageOutcome EHPCClient::pullImage(const PullImageRequest &request) const
|
|
|
{
|
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
|
if (!endpointOutcome.isSuccess())
|
|
|
- return StopNodesOutcome(endpointOutcome.error());
|
|
|
+ return PullImageOutcome(endpointOutcome.error());
|
|
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
|
|
if (outcome.isSuccess())
|
|
|
- return StopNodesOutcome(StopNodesResult(outcome.result()));
|
|
|
+ return PullImageOutcome(PullImageResult(outcome.result()));
|
|
|
else
|
|
|
- return StopNodesOutcome(outcome.error());
|
|
|
+ return PullImageOutcome(outcome.error());
|
|
|
}
|
|
|
|
|
|
-void EHPCClient::stopNodesAsync(const StopNodesRequest& request, const StopNodesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
|
+void EHPCClient::pullImageAsync(const PullImageRequest& request, const PullImageAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
|
{
|
|
|
auto fn = [this, request, handler, context]()
|
|
|
{
|
|
|
- handler(this, request, stopNodes(request), context);
|
|
|
+ handler(this, request, pullImage(request), context);
|
|
|
};
|
|
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
|
}
|
|
|
|
|
|
-EHPCClient::StopNodesOutcomeCallable EHPCClient::stopNodesCallable(const StopNodesRequest &request) const
|
|
|
+EHPCClient::PullImageOutcomeCallable EHPCClient::pullImageCallable(const PullImageRequest &request) const
|
|
|
{
|
|
|
- auto task = std::make_shared<std::packaged_task<StopNodesOutcome()>>(
|
|
|
+ auto task = std::make_shared<std::packaged_task<PullImageOutcome()>>(
|
|
|
[this, request]()
|
|
|
{
|
|
|
- return this->stopNodes(request);
|
|
|
+ return this->pullImage(request);
|
|
|
});
|
|
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
|
return task->get_future();
|
|
|
}
|
|
|
|
|
|
-EHPCClient::ListCurrentClientVersionOutcome EHPCClient::listCurrentClientVersion(const ListCurrentClientVersionRequest &request) const
|
|
|
+EHPCClient::DescribeContainerAppOutcome EHPCClient::describeContainerApp(const DescribeContainerAppRequest &request) const
|
|
|
{
|
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
|
if (!endpointOutcome.isSuccess())
|
|
|
- return ListCurrentClientVersionOutcome(endpointOutcome.error());
|
|
|
+ return DescribeContainerAppOutcome(endpointOutcome.error());
|
|
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
|
|
if (outcome.isSuccess())
|
|
|
- return ListCurrentClientVersionOutcome(ListCurrentClientVersionResult(outcome.result()));
|
|
|
+ return DescribeContainerAppOutcome(DescribeContainerAppResult(outcome.result()));
|
|
|
else
|
|
|
- return ListCurrentClientVersionOutcome(outcome.error());
|
|
|
+ return DescribeContainerAppOutcome(outcome.error());
|
|
|
}
|
|
|
|
|
|
-void EHPCClient::listCurrentClientVersionAsync(const ListCurrentClientVersionRequest& request, const ListCurrentClientVersionAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
|
+void EHPCClient::describeContainerAppAsync(const DescribeContainerAppRequest& request, const DescribeContainerAppAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
|
{
|
|
|
auto fn = [this, request, handler, context]()
|
|
|
{
|
|
|
- handler(this, request, listCurrentClientVersion(request), context);
|
|
|
+ handler(this, request, describeContainerApp(request), context);
|
|
|
};
|
|
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
|
}
|
|
|
|
|
|
-EHPCClient::ListCurrentClientVersionOutcomeCallable EHPCClient::listCurrentClientVersionCallable(const ListCurrentClientVersionRequest &request) const
|
|
|
+EHPCClient::DescribeContainerAppOutcomeCallable EHPCClient::describeContainerAppCallable(const DescribeContainerAppRequest &request) const
|
|
|
{
|
|
|
- auto task = std::make_shared<std::packaged_task<ListCurrentClientVersionOutcome()>>(
|
|
|
+ auto task = std::make_shared<std::packaged_task<DescribeContainerAppOutcome()>>(
|
|
|
[this, request]()
|
|
|
{
|
|
|
- return this->listCurrentClientVersion(request);
|
|
|
+ return this->describeContainerApp(request);
|
|
|
});
|
|
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
|
return task->get_future();
|
|
|
}
|
|
|
|
|
|
-EHPCClient::DeleteClusterOutcome EHPCClient::deleteCluster(const DeleteClusterRequest &request) const
|
|
|
+EHPCClient::ListCurrentClientVersionOutcome EHPCClient::listCurrentClientVersion(const ListCurrentClientVersionRequest &request) const
|
|
|
{
|
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
|
if (!endpointOutcome.isSuccess())
|
|
|
- return DeleteClusterOutcome(endpointOutcome.error());
|
|
|
+ return ListCurrentClientVersionOutcome(endpointOutcome.error());
|
|
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
|
|
if (outcome.isSuccess())
|
|
|
- return DeleteClusterOutcome(DeleteClusterResult(outcome.result()));
|
|
|
+ return ListCurrentClientVersionOutcome(ListCurrentClientVersionResult(outcome.result()));
|
|
|
else
|
|
|
- return DeleteClusterOutcome(outcome.error());
|
|
|
+ return ListCurrentClientVersionOutcome(outcome.error());
|
|
|
}
|
|
|
|
|
|
-void EHPCClient::deleteClusterAsync(const DeleteClusterRequest& request, const DeleteClusterAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
|
+void EHPCClient::listCurrentClientVersionAsync(const ListCurrentClientVersionRequest& request, const ListCurrentClientVersionAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
|
{
|
|
|
auto fn = [this, request, handler, context]()
|
|
|
{
|
|
|
- handler(this, request, deleteCluster(request), context);
|
|
|
+ handler(this, request, listCurrentClientVersion(request), context);
|
|
|
};
|
|
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
|
}
|
|
|
|
|
|
-EHPCClient::DeleteClusterOutcomeCallable EHPCClient::deleteClusterCallable(const DeleteClusterRequest &request) const
|
|
|
+EHPCClient::ListCurrentClientVersionOutcomeCallable EHPCClient::listCurrentClientVersionCallable(const ListCurrentClientVersionRequest &request) const
|
|
|
{
|
|
|
- auto task = std::make_shared<std::packaged_task<DeleteClusterOutcome()>>(
|
|
|
+ auto task = std::make_shared<std::packaged_task<ListCurrentClientVersionOutcome()>>(
|
|
|
[this, request]()
|
|
|
{
|
|
|
- return this->deleteCluster(request);
|
|
|
+ return this->listCurrentClientVersion(request);
|
|
|
});
|
|
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
|
return task->get_future();
|
|
|
}
|
|
|
|
|
|
-EHPCClient::ListImagesOutcome EHPCClient::listImages(const ListImagesRequest &request) const
|
|
|
+EHPCClient::ModifyContainerAppAttributesOutcome EHPCClient::modifyContainerAppAttributes(const ModifyContainerAppAttributesRequest &request) const
|
|
|
{
|
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
|
if (!endpointOutcome.isSuccess())
|
|
|
- return ListImagesOutcome(endpointOutcome.error());
|
|
|
+ return ModifyContainerAppAttributesOutcome(endpointOutcome.error());
|
|
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
|
|
if (outcome.isSuccess())
|
|
|
- return ListImagesOutcome(ListImagesResult(outcome.result()));
|
|
|
+ return ModifyContainerAppAttributesOutcome(ModifyContainerAppAttributesResult(outcome.result()));
|
|
|
else
|
|
|
- return ListImagesOutcome(outcome.error());
|
|
|
+ return ModifyContainerAppAttributesOutcome(outcome.error());
|
|
|
}
|
|
|
|
|
|
-void EHPCClient::listImagesAsync(const ListImagesRequest& request, const ListImagesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
|
+void EHPCClient::modifyContainerAppAttributesAsync(const ModifyContainerAppAttributesRequest& request, const ModifyContainerAppAttributesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
|
{
|
|
|
auto fn = [this, request, handler, context]()
|
|
|
{
|
|
|
- handler(this, request, listImages(request), context);
|
|
|
+ handler(this, request, modifyContainerAppAttributes(request), context);
|
|
|
};
|
|
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
|
}
|
|
|
|
|
|
-EHPCClient::ListImagesOutcomeCallable EHPCClient::listImagesCallable(const ListImagesRequest &request) const
|
|
|
+EHPCClient::ModifyContainerAppAttributesOutcomeCallable EHPCClient::modifyContainerAppAttributesCallable(const ModifyContainerAppAttributesRequest &request) const
|
|
|
{
|
|
|
- auto task = std::make_shared<std::packaged_task<ListImagesOutcome()>>(
|
|
|
+ auto task = std::make_shared<std::packaged_task<ModifyContainerAppAttributesOutcome()>>(
|
|
|
[this, request]()
|
|
|
{
|
|
|
- return this->listImages(request);
|
|
|
+ return this->modifyContainerAppAttributes(request);
|
|
|
});
|
|
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
|
@@ -375,36 +375,36 @@ EHPCClient::SetAutoScaleConfigOutcomeCallable EHPCClient::setAutoScaleConfigCall
|
|
|
return task->get_future();
|
|
|
}
|
|
|
|
|
|
-EHPCClient::ListVolumesOutcome EHPCClient::listVolumes(const ListVolumesRequest &request) const
|
|
|
+EHPCClient::ListInvocationResultsOutcome EHPCClient::listInvocationResults(const ListInvocationResultsRequest &request) const
|
|
|
{
|
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
|
if (!endpointOutcome.isSuccess())
|
|
|
- return ListVolumesOutcome(endpointOutcome.error());
|
|
|
+ return ListInvocationResultsOutcome(endpointOutcome.error());
|
|
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
|
|
if (outcome.isSuccess())
|
|
|
- return ListVolumesOutcome(ListVolumesResult(outcome.result()));
|
|
|
+ return ListInvocationResultsOutcome(ListInvocationResultsResult(outcome.result()));
|
|
|
else
|
|
|
- return ListVolumesOutcome(outcome.error());
|
|
|
+ return ListInvocationResultsOutcome(outcome.error());
|
|
|
}
|
|
|
|
|
|
-void EHPCClient::listVolumesAsync(const ListVolumesRequest& request, const ListVolumesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
|
+void EHPCClient::listInvocationResultsAsync(const ListInvocationResultsRequest& request, const ListInvocationResultsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
|
{
|
|
|
auto fn = [this, request, handler, context]()
|
|
|
{
|
|
|
- handler(this, request, listVolumes(request), context);
|
|
|
+ handler(this, request, listInvocationResults(request), context);
|
|
|
};
|
|
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
|
}
|
|
|
|
|
|
-EHPCClient::ListVolumesOutcomeCallable EHPCClient::listVolumesCallable(const ListVolumesRequest &request) const
|
|
|
+EHPCClient::ListInvocationResultsOutcomeCallable EHPCClient::listInvocationResultsCallable(const ListInvocationResultsRequest &request) const
|
|
|
{
|
|
|
- auto task = std::make_shared<std::packaged_task<ListVolumesOutcome()>>(
|
|
|
+ auto task = std::make_shared<std::packaged_task<ListInvocationResultsOutcome()>>(
|
|
|
[this, request]()
|
|
|
{
|
|
|
- return this->listVolumes(request);
|
|
|
+ return this->listInvocationResults(request);
|
|
|
});
|
|
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
|
@@ -627,42 +627,6 @@ EHPCClient::ListNodesOutcomeCallable EHPCClient::listNodesCallable(const ListNod
|
|
|
return task->get_future();
|
|
|
}
|
|
|
|
|
|
-EHPCClient::SetJobUserOutcome EHPCClient::setJobUser(const SetJobUserRequest &request) const
|
|
|
-{
|
|
|
- auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
|
- if (!endpointOutcome.isSuccess())
|
|
|
- return SetJobUserOutcome(endpointOutcome.error());
|
|
|
-
|
|
|
- auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
-
|
|
|
- if (outcome.isSuccess())
|
|
|
- return SetJobUserOutcome(SetJobUserResult(outcome.result()));
|
|
|
- else
|
|
|
- return SetJobUserOutcome(outcome.error());
|
|
|
-}
|
|
|
-
|
|
|
-void EHPCClient::setJobUserAsync(const SetJobUserRequest& request, const SetJobUserAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
|
-{
|
|
|
- auto fn = [this, request, handler, context]()
|
|
|
- {
|
|
|
- handler(this, request, setJobUser(request), context);
|
|
|
- };
|
|
|
-
|
|
|
- asyncExecute(new Runnable(fn));
|
|
|
-}
|
|
|
-
|
|
|
-EHPCClient::SetJobUserOutcomeCallable EHPCClient::setJobUserCallable(const SetJobUserRequest &request) const
|
|
|
-{
|
|
|
- auto task = std::make_shared<std::packaged_task<SetJobUserOutcome()>>(
|
|
|
- [this, request]()
|
|
|
- {
|
|
|
- return this->setJobUser(request);
|
|
|
- });
|
|
|
-
|
|
|
- asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
|
- return task->get_future();
|
|
|
-}
|
|
|
-
|
|
|
EHPCClient::ModifyUserGroupsOutcome EHPCClient::modifyUserGroups(const ModifyUserGroupsRequest &request) const
|
|
|
{
|
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
|
@@ -735,72 +699,36 @@ EHPCClient::StartClusterOutcomeCallable EHPCClient::startClusterCallable(const S
|
|
|
return task->get_future();
|
|
|
}
|
|
|
|
|
|
-EHPCClient::ListClustersOutcome EHPCClient::listClusters(const ListClustersRequest &request) const
|
|
|
-{
|
|
|
- auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
|
- if (!endpointOutcome.isSuccess())
|
|
|
- return ListClustersOutcome(endpointOutcome.error());
|
|
|
-
|
|
|
- auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
-
|
|
|
- if (outcome.isSuccess())
|
|
|
- return ListClustersOutcome(ListClustersResult(outcome.result()));
|
|
|
- else
|
|
|
- return ListClustersOutcome(outcome.error());
|
|
|
-}
|
|
|
-
|
|
|
-void EHPCClient::listClustersAsync(const ListClustersRequest& request, const ListClustersAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
|
-{
|
|
|
- auto fn = [this, request, handler, context]()
|
|
|
- {
|
|
|
- handler(this, request, listClusters(request), context);
|
|
|
- };
|
|
|
-
|
|
|
- asyncExecute(new Runnable(fn));
|
|
|
-}
|
|
|
-
|
|
|
-EHPCClient::ListClustersOutcomeCallable EHPCClient::listClustersCallable(const ListClustersRequest &request) const
|
|
|
-{
|
|
|
- auto task = std::make_shared<std::packaged_task<ListClustersOutcome()>>(
|
|
|
- [this, request]()
|
|
|
- {
|
|
|
- return this->listClusters(request);
|
|
|
- });
|
|
|
-
|
|
|
- asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
|
- return task->get_future();
|
|
|
-}
|
|
|
-
|
|
|
-EHPCClient::SubmitJobOutcome EHPCClient::submitJob(const SubmitJobRequest &request) const
|
|
|
+EHPCClient::ListCommandsOutcome EHPCClient::listCommands(const ListCommandsRequest &request) const
|
|
|
{
|
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
|
if (!endpointOutcome.isSuccess())
|
|
|
- return SubmitJobOutcome(endpointOutcome.error());
|
|
|
+ return ListCommandsOutcome(endpointOutcome.error());
|
|
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
|
|
if (outcome.isSuccess())
|
|
|
- return SubmitJobOutcome(SubmitJobResult(outcome.result()));
|
|
|
+ return ListCommandsOutcome(ListCommandsResult(outcome.result()));
|
|
|
else
|
|
|
- return SubmitJobOutcome(outcome.error());
|
|
|
+ return ListCommandsOutcome(outcome.error());
|
|
|
}
|
|
|
|
|
|
-void EHPCClient::submitJobAsync(const SubmitJobRequest& request, const SubmitJobAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
|
+void EHPCClient::listCommandsAsync(const ListCommandsRequest& request, const ListCommandsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
|
{
|
|
|
auto fn = [this, request, handler, context]()
|
|
|
{
|
|
|
- handler(this, request, submitJob(request), context);
|
|
|
+ handler(this, request, listCommands(request), context);
|
|
|
};
|
|
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
|
}
|
|
|
|
|
|
-EHPCClient::SubmitJobOutcomeCallable EHPCClient::submitJobCallable(const SubmitJobRequest &request) const
|
|
|
+EHPCClient::ListCommandsOutcomeCallable EHPCClient::listCommandsCallable(const ListCommandsRequest &request) const
|
|
|
{
|
|
|
- auto task = std::make_shared<std::packaged_task<SubmitJobOutcome()>>(
|
|
|
+ auto task = std::make_shared<std::packaged_task<ListCommandsOutcome()>>(
|
|
|
[this, request]()
|
|
|
{
|
|
|
- return this->submitJob(request);
|
|
|
+ return this->listCommands(request);
|
|
|
});
|
|
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
|
@@ -843,36 +771,36 @@ EHPCClient::ListCustomImagesOutcomeCallable EHPCClient::listCustomImagesCallable
|
|
|
return task->get_future();
|
|
|
}
|
|
|
|
|
|
-EHPCClient::ListRegionsOutcome EHPCClient::listRegions(const ListRegionsRequest &request) const
|
|
|
+EHPCClient::InvokeShellCommandOutcome EHPCClient::invokeShellCommand(const InvokeShellCommandRequest &request) const
|
|
|
{
|
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
|
if (!endpointOutcome.isSuccess())
|
|
|
- return ListRegionsOutcome(endpointOutcome.error());
|
|
|
+ return InvokeShellCommandOutcome(endpointOutcome.error());
|
|
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
|
|
if (outcome.isSuccess())
|
|
|
- return ListRegionsOutcome(ListRegionsResult(outcome.result()));
|
|
|
+ return InvokeShellCommandOutcome(InvokeShellCommandResult(outcome.result()));
|
|
|
else
|
|
|
- return ListRegionsOutcome(outcome.error());
|
|
|
+ return InvokeShellCommandOutcome(outcome.error());
|
|
|
}
|
|
|
|
|
|
-void EHPCClient::listRegionsAsync(const ListRegionsRequest& request, const ListRegionsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
|
+void EHPCClient::invokeShellCommandAsync(const InvokeShellCommandRequest& request, const InvokeShellCommandAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
|
{
|
|
|
auto fn = [this, request, handler, context]()
|
|
|
{
|
|
|
- handler(this, request, listRegions(request), context);
|
|
|
+ handler(this, request, invokeShellCommand(request), context);
|
|
|
};
|
|
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
|
}
|
|
|
|
|
|
-EHPCClient::ListRegionsOutcomeCallable EHPCClient::listRegionsCallable(const ListRegionsRequest &request) const
|
|
|
+EHPCClient::InvokeShellCommandOutcomeCallable EHPCClient::invokeShellCommandCallable(const InvokeShellCommandRequest &request) const
|
|
|
{
|
|
|
- auto task = std::make_shared<std::packaged_task<ListRegionsOutcome()>>(
|
|
|
+ auto task = std::make_shared<std::packaged_task<InvokeShellCommandOutcome()>>(
|
|
|
[this, request]()
|
|
|
{
|
|
|
- return this->listRegions(request);
|
|
|
+ return this->invokeShellCommand(request);
|
|
|
});
|
|
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
|
@@ -1095,72 +1023,72 @@ EHPCClient::ListNodesNoPagingOutcomeCallable EHPCClient::listNodesNoPagingCallab
|
|
|
return task->get_future();
|
|
|
}
|
|
|
|
|
|
-EHPCClient::CreateJobTemplateOutcome EHPCClient::createJobTemplate(const CreateJobTemplateRequest &request) const
|
|
|
+EHPCClient::GetHybridClusterConfigOutcome EHPCClient::getHybridClusterConfig(const GetHybridClusterConfigRequest &request) const
|
|
|
{
|
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
|
if (!endpointOutcome.isSuccess())
|
|
|
- return CreateJobTemplateOutcome(endpointOutcome.error());
|
|
|
+ return GetHybridClusterConfigOutcome(endpointOutcome.error());
|
|
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
|
|
if (outcome.isSuccess())
|
|
|
- return CreateJobTemplateOutcome(CreateJobTemplateResult(outcome.result()));
|
|
|
+ return GetHybridClusterConfigOutcome(GetHybridClusterConfigResult(outcome.result()));
|
|
|
else
|
|
|
- return CreateJobTemplateOutcome(outcome.error());
|
|
|
+ return GetHybridClusterConfigOutcome(outcome.error());
|
|
|
}
|
|
|
|
|
|
-void EHPCClient::createJobTemplateAsync(const CreateJobTemplateRequest& request, const CreateJobTemplateAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
|
+void EHPCClient::getHybridClusterConfigAsync(const GetHybridClusterConfigRequest& request, const GetHybridClusterConfigAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
|
{
|
|
|
auto fn = [this, request, handler, context]()
|
|
|
{
|
|
|
- handler(this, request, createJobTemplate(request), context);
|
|
|
+ handler(this, request, getHybridClusterConfig(request), context);
|
|
|
};
|
|
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
|
}
|
|
|
|
|
|
-EHPCClient::CreateJobTemplateOutcomeCallable EHPCClient::createJobTemplateCallable(const CreateJobTemplateRequest &request) const
|
|
|
+EHPCClient::GetHybridClusterConfigOutcomeCallable EHPCClient::getHybridClusterConfigCallable(const GetHybridClusterConfigRequest &request) const
|
|
|
{
|
|
|
- auto task = std::make_shared<std::packaged_task<CreateJobTemplateOutcome()>>(
|
|
|
+ auto task = std::make_shared<std::packaged_task<GetHybridClusterConfigOutcome()>>(
|
|
|
[this, request]()
|
|
|
{
|
|
|
- return this->createJobTemplate(request);
|
|
|
+ return this->getHybridClusterConfig(request);
|
|
|
});
|
|
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
|
return task->get_future();
|
|
|
}
|
|
|
|
|
|
-EHPCClient::RerunJobsOutcome EHPCClient::rerunJobs(const RerunJobsRequest &request) const
|
|
|
+EHPCClient::CreateJobTemplateOutcome EHPCClient::createJobTemplate(const CreateJobTemplateRequest &request) const
|
|
|
{
|
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
|
if (!endpointOutcome.isSuccess())
|
|
|
- return RerunJobsOutcome(endpointOutcome.error());
|
|
|
+ return CreateJobTemplateOutcome(endpointOutcome.error());
|
|
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
|
|
if (outcome.isSuccess())
|
|
|
- return RerunJobsOutcome(RerunJobsResult(outcome.result()));
|
|
|
+ return CreateJobTemplateOutcome(CreateJobTemplateResult(outcome.result()));
|
|
|
else
|
|
|
- return RerunJobsOutcome(outcome.error());
|
|
|
+ return CreateJobTemplateOutcome(outcome.error());
|
|
|
}
|
|
|
|
|
|
-void EHPCClient::rerunJobsAsync(const RerunJobsRequest& request, const RerunJobsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
|
+void EHPCClient::createJobTemplateAsync(const CreateJobTemplateRequest& request, const CreateJobTemplateAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
|
{
|
|
|
auto fn = [this, request, handler, context]()
|
|
|
{
|
|
|
- handler(this, request, rerunJobs(request), context);
|
|
|
+ handler(this, request, createJobTemplate(request), context);
|
|
|
};
|
|
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
|
}
|
|
|
|
|
|
-EHPCClient::RerunJobsOutcomeCallable EHPCClient::rerunJobsCallable(const RerunJobsRequest &request) const
|
|
|
+EHPCClient::CreateJobTemplateOutcomeCallable EHPCClient::createJobTemplateCallable(const CreateJobTemplateRequest &request) const
|
|
|
{
|
|
|
- auto task = std::make_shared<std::packaged_task<RerunJobsOutcome()>>(
|
|
|
+ auto task = std::make_shared<std::packaged_task<CreateJobTemplateOutcome()>>(
|
|
|
[this, request]()
|
|
|
{
|
|
|
- return this->rerunJobs(request);
|
|
|
+ return this->createJobTemplate(request);
|
|
|
});
|
|
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
|
@@ -1203,324 +1131,900 @@ EHPCClient::ResetNodesOutcomeCallable EHPCClient::resetNodesCallable(const Reset
|
|
|
return task->get_future();
|
|
|
}
|
|
|
|
|
|
-EHPCClient::EditJobTemplateOutcome EHPCClient::editJobTemplate(const EditJobTemplateRequest &request) const
|
|
|
+EHPCClient::CreateHybridClusterOutcome EHPCClient::createHybridCluster(const CreateHybridClusterRequest &request) const
|
|
|
{
|
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
|
if (!endpointOutcome.isSuccess())
|
|
|
- return EditJobTemplateOutcome(endpointOutcome.error());
|
|
|
+ return CreateHybridClusterOutcome(endpointOutcome.error());
|
|
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
|
|
if (outcome.isSuccess())
|
|
|
- return EditJobTemplateOutcome(EditJobTemplateResult(outcome.result()));
|
|
|
+ return CreateHybridClusterOutcome(CreateHybridClusterResult(outcome.result()));
|
|
|
else
|
|
|
- return EditJobTemplateOutcome(outcome.error());
|
|
|
+ return CreateHybridClusterOutcome(outcome.error());
|
|
|
}
|
|
|
|
|
|
-void EHPCClient::editJobTemplateAsync(const EditJobTemplateRequest& request, const EditJobTemplateAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
|
+void EHPCClient::createHybridClusterAsync(const CreateHybridClusterRequest& request, const CreateHybridClusterAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
|
{
|
|
|
auto fn = [this, request, handler, context]()
|
|
|
{
|
|
|
- handler(this, request, editJobTemplate(request), context);
|
|
|
+ handler(this, request, createHybridCluster(request), context);
|
|
|
};
|
|
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
|
}
|
|
|
|
|
|
-EHPCClient::EditJobTemplateOutcomeCallable EHPCClient::editJobTemplateCallable(const EditJobTemplateRequest &request) const
|
|
|
+EHPCClient::CreateHybridClusterOutcomeCallable EHPCClient::createHybridClusterCallable(const CreateHybridClusterRequest &request) const
|
|
|
{
|
|
|
- auto task = std::make_shared<std::packaged_task<EditJobTemplateOutcome()>>(
|
|
|
+ auto task = std::make_shared<std::packaged_task<CreateHybridClusterOutcome()>>(
|
|
|
[this, request]()
|
|
|
{
|
|
|
- return this->editJobTemplate(request);
|
|
|
+ return this->createHybridCluster(request);
|
|
|
});
|
|
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
|
return task->get_future();
|
|
|
}
|
|
|
|
|
|
-EHPCClient::ListPreferredEcsTypesOutcome EHPCClient::listPreferredEcsTypes(const ListPreferredEcsTypesRequest &request) const
|
|
|
+EHPCClient::ListContainerImagesOutcome EHPCClient::listContainerImages(const ListContainerImagesRequest &request) const
|
|
|
{
|
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
|
if (!endpointOutcome.isSuccess())
|
|
|
- return ListPreferredEcsTypesOutcome(endpointOutcome.error());
|
|
|
+ return ListContainerImagesOutcome(endpointOutcome.error());
|
|
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
|
|
if (outcome.isSuccess())
|
|
|
- return ListPreferredEcsTypesOutcome(ListPreferredEcsTypesResult(outcome.result()));
|
|
|
+ return ListContainerImagesOutcome(ListContainerImagesResult(outcome.result()));
|
|
|
else
|
|
|
- return ListPreferredEcsTypesOutcome(outcome.error());
|
|
|
+ return ListContainerImagesOutcome(outcome.error());
|
|
|
}
|
|
|
|
|
|
-void EHPCClient::listPreferredEcsTypesAsync(const ListPreferredEcsTypesRequest& request, const ListPreferredEcsTypesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
|
+void EHPCClient::listContainerImagesAsync(const ListContainerImagesRequest& request, const ListContainerImagesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
|
{
|
|
|
auto fn = [this, request, handler, context]()
|
|
|
{
|
|
|
- handler(this, request, listPreferredEcsTypes(request), context);
|
|
|
+ handler(this, request, listContainerImages(request), context);
|
|
|
};
|
|
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
|
}
|
|
|
|
|
|
-EHPCClient::ListPreferredEcsTypesOutcomeCallable EHPCClient::listPreferredEcsTypesCallable(const ListPreferredEcsTypesRequest &request) const
|
|
|
+EHPCClient::ListContainerImagesOutcomeCallable EHPCClient::listContainerImagesCallable(const ListContainerImagesRequest &request) const
|
|
|
{
|
|
|
- auto task = std::make_shared<std::packaged_task<ListPreferredEcsTypesOutcome()>>(
|
|
|
+ auto task = std::make_shared<std::packaged_task<ListContainerImagesOutcome()>>(
|
|
|
[this, request]()
|
|
|
{
|
|
|
- return this->listPreferredEcsTypes(request);
|
|
|
+ return this->listContainerImages(request);
|
|
|
});
|
|
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
|
return task->get_future();
|
|
|
}
|
|
|
|
|
|
-EHPCClient::ListClusterLogsOutcome EHPCClient::listClusterLogs(const ListClusterLogsRequest &request) const
|
|
|
+EHPCClient::DeleteJobsOutcome EHPCClient::deleteJobs(const DeleteJobsRequest &request) const
|
|
|
{
|
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
|
if (!endpointOutcome.isSuccess())
|
|
|
- return ListClusterLogsOutcome(endpointOutcome.error());
|
|
|
+ return DeleteJobsOutcome(endpointOutcome.error());
|
|
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
|
|
if (outcome.isSuccess())
|
|
|
- return ListClusterLogsOutcome(ListClusterLogsResult(outcome.result()));
|
|
|
+ return DeleteJobsOutcome(DeleteJobsResult(outcome.result()));
|
|
|
else
|
|
|
- return ListClusterLogsOutcome(outcome.error());
|
|
|
+ return DeleteJobsOutcome(outcome.error());
|
|
|
}
|
|
|
|
|
|
-void EHPCClient::listClusterLogsAsync(const ListClusterLogsRequest& request, const ListClusterLogsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
|
+void EHPCClient::deleteJobsAsync(const DeleteJobsRequest& request, const DeleteJobsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
|
{
|
|
|
auto fn = [this, request, handler, context]()
|
|
|
{
|
|
|
- handler(this, request, listClusterLogs(request), context);
|
|
|
+ handler(this, request, deleteJobs(request), context);
|
|
|
};
|
|
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
|
}
|
|
|
|
|
|
-EHPCClient::ListClusterLogsOutcomeCallable EHPCClient::listClusterLogsCallable(const ListClusterLogsRequest &request) const
|
|
|
+EHPCClient::DeleteJobsOutcomeCallable EHPCClient::deleteJobsCallable(const DeleteJobsRequest &request) const
|
|
|
{
|
|
|
- auto task = std::make_shared<std::packaged_task<ListClusterLogsOutcome()>>(
|
|
|
+ auto task = std::make_shared<std::packaged_task<DeleteJobsOutcome()>>(
|
|
|
[this, request]()
|
|
|
{
|
|
|
- return this->listClusterLogs(request);
|
|
|
+ return this->deleteJobs(request);
|
|
|
});
|
|
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
|
return task->get_future();
|
|
|
}
|
|
|
|
|
|
-EHPCClient::RecoverClusterOutcome EHPCClient::recoverCluster(const RecoverClusterRequest &request) const
|
|
|
+EHPCClient::DeleteNodesOutcome EHPCClient::deleteNodes(const DeleteNodesRequest &request) const
|
|
|
{
|
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
|
if (!endpointOutcome.isSuccess())
|
|
|
- return RecoverClusterOutcome(endpointOutcome.error());
|
|
|
+ return DeleteNodesOutcome(endpointOutcome.error());
|
|
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
|
|
if (outcome.isSuccess())
|
|
|
- return RecoverClusterOutcome(RecoverClusterResult(outcome.result()));
|
|
|
+ return DeleteNodesOutcome(DeleteNodesResult(outcome.result()));
|
|
|
else
|
|
|
- return RecoverClusterOutcome(outcome.error());
|
|
|
+ return DeleteNodesOutcome(outcome.error());
|
|
|
}
|
|
|
|
|
|
-void EHPCClient::recoverClusterAsync(const RecoverClusterRequest& request, const RecoverClusterAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
|
+void EHPCClient::deleteNodesAsync(const DeleteNodesRequest& request, const DeleteNodesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
|
{
|
|
|
auto fn = [this, request, handler, context]()
|
|
|
{
|
|
|
- handler(this, request, recoverCluster(request), context);
|
|
|
+ handler(this, request, deleteNodes(request), context);
|
|
|
};
|
|
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
|
}
|
|
|
|
|
|
-EHPCClient::RecoverClusterOutcomeCallable EHPCClient::recoverClusterCallable(const RecoverClusterRequest &request) const
|
|
|
+EHPCClient::DeleteNodesOutcomeCallable EHPCClient::deleteNodesCallable(const DeleteNodesRequest &request) const
|
|
|
{
|
|
|
- auto task = std::make_shared<std::packaged_task<RecoverClusterOutcome()>>(
|
|
|
+ auto task = std::make_shared<std::packaged_task<DeleteNodesOutcome()>>(
|
|
|
[this, request]()
|
|
|
{
|
|
|
- return this->recoverCluster(request);
|
|
|
+ return this->deleteNodes(request);
|
|
|
});
|
|
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
|
return task->get_future();
|
|
|
}
|
|
|
|
|
|
-EHPCClient::DeleteJobsOutcome EHPCClient::deleteJobs(const DeleteJobsRequest &request) const
|
|
|
+EHPCClient::ListJobsOutcome EHPCClient::listJobs(const ListJobsRequest &request) const
|
|
|
{
|
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
|
if (!endpointOutcome.isSuccess())
|
|
|
- return DeleteJobsOutcome(endpointOutcome.error());
|
|
|
+ return ListJobsOutcome(endpointOutcome.error());
|
|
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
|
|
if (outcome.isSuccess())
|
|
|
- return DeleteJobsOutcome(DeleteJobsResult(outcome.result()));
|
|
|
+ return ListJobsOutcome(ListJobsResult(outcome.result()));
|
|
|
else
|
|
|
- return DeleteJobsOutcome(outcome.error());
|
|
|
+ return ListJobsOutcome(outcome.error());
|
|
|
}
|
|
|
|
|
|
-void EHPCClient::deleteJobsAsync(const DeleteJobsRequest& request, const DeleteJobsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
|
+void EHPCClient::listJobsAsync(const ListJobsRequest& request, const ListJobsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
|
{
|
|
|
auto fn = [this, request, handler, context]()
|
|
|
{
|
|
|
- handler(this, request, deleteJobs(request), context);
|
|
|
+ handler(this, request, listJobs(request), context);
|
|
|
};
|
|
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
|
}
|
|
|
|
|
|
-EHPCClient::DeleteJobsOutcomeCallable EHPCClient::deleteJobsCallable(const DeleteJobsRequest &request) const
|
|
|
+EHPCClient::ListJobsOutcomeCallable EHPCClient::listJobsCallable(const ListJobsRequest &request) const
|
|
|
+{
|
|
|
+ auto task = std::make_shared<std::packaged_task<ListJobsOutcome()>>(
|
|
|
+ [this, request]()
|
|
|
+ {
|
|
|
+ return this->listJobs(request);
|
|
|
+ });
|
|
|
+
|
|
|
+ asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
|
+ return task->get_future();
|
|
|
+}
|
|
|
+
|
|
|
+EHPCClient::CreateClusterOutcome EHPCClient::createCluster(const CreateClusterRequest &request) const
|
|
|
+{
|
|
|
+ auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
|
+ if (!endpointOutcome.isSuccess())
|
|
|
+ return CreateClusterOutcome(endpointOutcome.error());
|
|
|
+
|
|
|
+ auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
+
|
|
|
+ if (outcome.isSuccess())
|
|
|
+ return CreateClusterOutcome(CreateClusterResult(outcome.result()));
|
|
|
+ else
|
|
|
+ return CreateClusterOutcome(outcome.error());
|
|
|
+}
|
|
|
+
|
|
|
+void EHPCClient::createClusterAsync(const CreateClusterRequest& request, const CreateClusterAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
|
+{
|
|
|
+ auto fn = [this, request, handler, context]()
|
|
|
+ {
|
|
|
+ handler(this, request, createCluster(request), context);
|
|
|
+ };
|
|
|
+
|
|
|
+ asyncExecute(new Runnable(fn));
|
|
|
+}
|
|
|
+
|
|
|
+EHPCClient::CreateClusterOutcomeCallable EHPCClient::createClusterCallable(const CreateClusterRequest &request) const
|
|
|
+{
|
|
|
+ auto task = std::make_shared<std::packaged_task<CreateClusterOutcome()>>(
|
|
|
+ [this, request]()
|
|
|
+ {
|
|
|
+ return this->createCluster(request);
|
|
|
+ });
|
|
|
+
|
|
|
+ asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
|
+ return task->get_future();
|
|
|
+}
|
|
|
+
|
|
|
+EHPCClient::ModifyUserPasswordsOutcome EHPCClient::modifyUserPasswords(const ModifyUserPasswordsRequest &request) const
|
|
|
+{
|
|
|
+ auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
|
+ if (!endpointOutcome.isSuccess())
|
|
|
+ return ModifyUserPasswordsOutcome(endpointOutcome.error());
|
|
|
+
|
|
|
+ auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
+
|
|
|
+ if (outcome.isSuccess())
|
|
|
+ return ModifyUserPasswordsOutcome(ModifyUserPasswordsResult(outcome.result()));
|
|
|
+ else
|
|
|
+ return ModifyUserPasswordsOutcome(outcome.error());
|
|
|
+}
|
|
|
+
|
|
|
+void EHPCClient::modifyUserPasswordsAsync(const ModifyUserPasswordsRequest& request, const ModifyUserPasswordsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
|
+{
|
|
|
+ auto fn = [this, request, handler, context]()
|
|
|
+ {
|
|
|
+ handler(this, request, modifyUserPasswords(request), context);
|
|
|
+ };
|
|
|
+
|
|
|
+ asyncExecute(new Runnable(fn));
|
|
|
+}
|
|
|
+
|
|
|
+EHPCClient::ModifyUserPasswordsOutcomeCallable EHPCClient::modifyUserPasswordsCallable(const ModifyUserPasswordsRequest &request) const
|
|
|
+{
|
|
|
+ auto task = std::make_shared<std::packaged_task<ModifyUserPasswordsOutcome()>>(
|
|
|
+ [this, request]()
|
|
|
+ {
|
|
|
+ return this->modifyUserPasswords(request);
|
|
|
+ });
|
|
|
+
|
|
|
+ asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
|
+ return task->get_future();
|
|
|
+}
|
|
|
+
|
|
|
+EHPCClient::UpgradeClientOutcome EHPCClient::upgradeClient(const UpgradeClientRequest &request) const
|
|
|
+{
|
|
|
+ auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
|
+ if (!endpointOutcome.isSuccess())
|
|
|
+ return UpgradeClientOutcome(endpointOutcome.error());
|
|
|
+
|
|
|
+ auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
+
|
|
|
+ if (outcome.isSuccess())
|
|
|
+ return UpgradeClientOutcome(UpgradeClientResult(outcome.result()));
|
|
|
+ else
|
|
|
+ return UpgradeClientOutcome(outcome.error());
|
|
|
+}
|
|
|
+
|
|
|
+void EHPCClient::upgradeClientAsync(const UpgradeClientRequest& request, const UpgradeClientAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
|
+{
|
|
|
+ auto fn = [this, request, handler, context]()
|
|
|
+ {
|
|
|
+ handler(this, request, upgradeClient(request), context);
|
|
|
+ };
|
|
|
+
|
|
|
+ asyncExecute(new Runnable(fn));
|
|
|
+}
|
|
|
+
|
|
|
+EHPCClient::UpgradeClientOutcomeCallable EHPCClient::upgradeClientCallable(const UpgradeClientRequest &request) const
|
|
|
+{
|
|
|
+ auto task = std::make_shared<std::packaged_task<UpgradeClientOutcome()>>(
|
|
|
+ [this, request]()
|
|
|
+ {
|
|
|
+ return this->upgradeClient(request);
|
|
|
+ });
|
|
|
+
|
|
|
+ asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
|
+ return task->get_future();
|
|
|
+}
|
|
|
+
|
|
|
+EHPCClient::DeleteClusterOutcome EHPCClient::deleteCluster(const DeleteClusterRequest &request) const
|
|
|
+{
|
|
|
+ auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
|
+ if (!endpointOutcome.isSuccess())
|
|
|
+ return DeleteClusterOutcome(endpointOutcome.error());
|
|
|
+
|
|
|
+ auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
+
|
|
|
+ if (outcome.isSuccess())
|
|
|
+ return DeleteClusterOutcome(DeleteClusterResult(outcome.result()));
|
|
|
+ else
|
|
|
+ return DeleteClusterOutcome(outcome.error());
|
|
|
+}
|
|
|
+
|
|
|
+void EHPCClient::deleteClusterAsync(const DeleteClusterRequest& request, const DeleteClusterAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
|
+{
|
|
|
+ auto fn = [this, request, handler, context]()
|
|
|
+ {
|
|
|
+ handler(this, request, deleteCluster(request), context);
|
|
|
+ };
|
|
|
+
|
|
|
+ asyncExecute(new Runnable(fn));
|
|
|
+}
|
|
|
+
|
|
|
+EHPCClient::DeleteClusterOutcomeCallable EHPCClient::deleteClusterCallable(const DeleteClusterRequest &request) const
|
|
|
+{
|
|
|
+ auto task = std::make_shared<std::packaged_task<DeleteClusterOutcome()>>(
|
|
|
+ [this, request]()
|
|
|
+ {
|
|
|
+ return this->deleteCluster(request);
|
|
|
+ });
|
|
|
+
|
|
|
+ asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
|
+ return task->get_future();
|
|
|
+}
|
|
|
+
|
|
|
+EHPCClient::ListImagesOutcome EHPCClient::listImages(const ListImagesRequest &request) const
|
|
|
+{
|
|
|
+ auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
|
+ if (!endpointOutcome.isSuccess())
|
|
|
+ return ListImagesOutcome(endpointOutcome.error());
|
|
|
+
|
|
|
+ auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
+
|
|
|
+ if (outcome.isSuccess())
|
|
|
+ return ListImagesOutcome(ListImagesResult(outcome.result()));
|
|
|
+ else
|
|
|
+ return ListImagesOutcome(outcome.error());
|
|
|
+}
|
|
|
+
|
|
|
+void EHPCClient::listImagesAsync(const ListImagesRequest& request, const ListImagesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
|
+{
|
|
|
+ auto fn = [this, request, handler, context]()
|
|
|
+ {
|
|
|
+ handler(this, request, listImages(request), context);
|
|
|
+ };
|
|
|
+
|
|
|
+ asyncExecute(new Runnable(fn));
|
|
|
+}
|
|
|
+
|
|
|
+EHPCClient::ListImagesOutcomeCallable EHPCClient::listImagesCallable(const ListImagesRequest &request) const
|
|
|
+{
|
|
|
+ auto task = std::make_shared<std::packaged_task<ListImagesOutcome()>>(
|
|
|
+ [this, request]()
|
|
|
+ {
|
|
|
+ return this->listImages(request);
|
|
|
+ });
|
|
|
+
|
|
|
+ asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
|
+ return task->get_future();
|
|
|
+}
|
|
|
+
|
|
|
+EHPCClient::ListVolumesOutcome EHPCClient::listVolumes(const ListVolumesRequest &request) const
|
|
|
+{
|
|
|
+ auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
|
+ if (!endpointOutcome.isSuccess())
|
|
|
+ return ListVolumesOutcome(endpointOutcome.error());
|
|
|
+
|
|
|
+ auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
+
|
|
|
+ if (outcome.isSuccess())
|
|
|
+ return ListVolumesOutcome(ListVolumesResult(outcome.result()));
|
|
|
+ else
|
|
|
+ return ListVolumesOutcome(outcome.error());
|
|
|
+}
|
|
|
+
|
|
|
+void EHPCClient::listVolumesAsync(const ListVolumesRequest& request, const ListVolumesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
|
+{
|
|
|
+ auto fn = [this, request, handler, context]()
|
|
|
+ {
|
|
|
+ handler(this, request, listVolumes(request), context);
|
|
|
+ };
|
|
|
+
|
|
|
+ asyncExecute(new Runnable(fn));
|
|
|
+}
|
|
|
+
|
|
|
+EHPCClient::ListVolumesOutcomeCallable EHPCClient::listVolumesCallable(const ListVolumesRequest &request) const
|
|
|
+{
|
|
|
+ auto task = std::make_shared<std::packaged_task<ListVolumesOutcome()>>(
|
|
|
+ [this, request]()
|
|
|
+ {
|
|
|
+ return this->listVolumes(request);
|
|
|
+ });
|
|
|
+
|
|
|
+ asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
|
+ return task->get_future();
|
|
|
+}
|
|
|
+
|
|
|
+EHPCClient::DeleteContainerAppsOutcome EHPCClient::deleteContainerApps(const DeleteContainerAppsRequest &request) const
|
|
|
+{
|
|
|
+ auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
|
+ if (!endpointOutcome.isSuccess())
|
|
|
+ return DeleteContainerAppsOutcome(endpointOutcome.error());
|
|
|
+
|
|
|
+ auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
+
|
|
|
+ if (outcome.isSuccess())
|
|
|
+ return DeleteContainerAppsOutcome(DeleteContainerAppsResult(outcome.result()));
|
|
|
+ else
|
|
|
+ return DeleteContainerAppsOutcome(outcome.error());
|
|
|
+}
|
|
|
+
|
|
|
+void EHPCClient::deleteContainerAppsAsync(const DeleteContainerAppsRequest& request, const DeleteContainerAppsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
|
+{
|
|
|
+ auto fn = [this, request, handler, context]()
|
|
|
+ {
|
|
|
+ handler(this, request, deleteContainerApps(request), context);
|
|
|
+ };
|
|
|
+
|
|
|
+ asyncExecute(new Runnable(fn));
|
|
|
+}
|
|
|
+
|
|
|
+EHPCClient::DeleteContainerAppsOutcomeCallable EHPCClient::deleteContainerAppsCallable(const DeleteContainerAppsRequest &request) const
|
|
|
+{
|
|
|
+ auto task = std::make_shared<std::packaged_task<DeleteContainerAppsOutcome()>>(
|
|
|
+ [this, request]()
|
|
|
+ {
|
|
|
+ return this->deleteContainerApps(request);
|
|
|
+ });
|
|
|
+
|
|
|
+ asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
|
+ return task->get_future();
|
|
|
+}
|
|
|
+
|
|
|
+EHPCClient::ListInvocationStatusOutcome EHPCClient::listInvocationStatus(const ListInvocationStatusRequest &request) const
|
|
|
+{
|
|
|
+ auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
|
+ if (!endpointOutcome.isSuccess())
|
|
|
+ return ListInvocationStatusOutcome(endpointOutcome.error());
|
|
|
+
|
|
|
+ auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
+
|
|
|
+ if (outcome.isSuccess())
|
|
|
+ return ListInvocationStatusOutcome(ListInvocationStatusResult(outcome.result()));
|
|
|
+ else
|
|
|
+ return ListInvocationStatusOutcome(outcome.error());
|
|
|
+}
|
|
|
+
|
|
|
+void EHPCClient::listInvocationStatusAsync(const ListInvocationStatusRequest& request, const ListInvocationStatusAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
|
+{
|
|
|
+ auto fn = [this, request, handler, context]()
|
|
|
+ {
|
|
|
+ handler(this, request, listInvocationStatus(request), context);
|
|
|
+ };
|
|
|
+
|
|
|
+ asyncExecute(new Runnable(fn));
|
|
|
+}
|
|
|
+
|
|
|
+EHPCClient::ListInvocationStatusOutcomeCallable EHPCClient::listInvocationStatusCallable(const ListInvocationStatusRequest &request) const
|
|
|
+{
|
|
|
+ auto task = std::make_shared<std::packaged_task<ListInvocationStatusOutcome()>>(
|
|
|
+ [this, request]()
|
|
|
+ {
|
|
|
+ return this->listInvocationStatus(request);
|
|
|
+ });
|
|
|
+
|
|
|
+ asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
|
+ return task->get_future();
|
|
|
+}
|
|
|
+
|
|
|
+EHPCClient::ListContainerAppsOutcome EHPCClient::listContainerApps(const ListContainerAppsRequest &request) const
|
|
|
+{
|
|
|
+ auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
|
+ if (!endpointOutcome.isSuccess())
|
|
|
+ return ListContainerAppsOutcome(endpointOutcome.error());
|
|
|
+
|
|
|
+ auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
+
|
|
|
+ if (outcome.isSuccess())
|
|
|
+ return ListContainerAppsOutcome(ListContainerAppsResult(outcome.result()));
|
|
|
+ else
|
|
|
+ return ListContainerAppsOutcome(outcome.error());
|
|
|
+}
|
|
|
+
|
|
|
+void EHPCClient::listContainerAppsAsync(const ListContainerAppsRequest& request, const ListContainerAppsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
|
+{
|
|
|
+ auto fn = [this, request, handler, context]()
|
|
|
+ {
|
|
|
+ handler(this, request, listContainerApps(request), context);
|
|
|
+ };
|
|
|
+
|
|
|
+ asyncExecute(new Runnable(fn));
|
|
|
+}
|
|
|
+
|
|
|
+EHPCClient::ListContainerAppsOutcomeCallable EHPCClient::listContainerAppsCallable(const ListContainerAppsRequest &request) const
|
|
|
+{
|
|
|
+ auto task = std::make_shared<std::packaged_task<ListContainerAppsOutcome()>>(
|
|
|
+ [this, request]()
|
|
|
+ {
|
|
|
+ return this->listContainerApps(request);
|
|
|
+ });
|
|
|
+
|
|
|
+ asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
|
+ return task->get_future();
|
|
|
+}
|
|
|
+
|
|
|
+EHPCClient::SetJobUserOutcome EHPCClient::setJobUser(const SetJobUserRequest &request) const
|
|
|
+{
|
|
|
+ auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
|
+ if (!endpointOutcome.isSuccess())
|
|
|
+ return SetJobUserOutcome(endpointOutcome.error());
|
|
|
+
|
|
|
+ auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
+
|
|
|
+ if (outcome.isSuccess())
|
|
|
+ return SetJobUserOutcome(SetJobUserResult(outcome.result()));
|
|
|
+ else
|
|
|
+ return SetJobUserOutcome(outcome.error());
|
|
|
+}
|
|
|
+
|
|
|
+void EHPCClient::setJobUserAsync(const SetJobUserRequest& request, const SetJobUserAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
|
+{
|
|
|
+ auto fn = [this, request, handler, context]()
|
|
|
+ {
|
|
|
+ handler(this, request, setJobUser(request), context);
|
|
|
+ };
|
|
|
+
|
|
|
+ asyncExecute(new Runnable(fn));
|
|
|
+}
|
|
|
+
|
|
|
+EHPCClient::SetJobUserOutcomeCallable EHPCClient::setJobUserCallable(const SetJobUserRequest &request) const
|
|
|
+{
|
|
|
+ auto task = std::make_shared<std::packaged_task<SetJobUserOutcome()>>(
|
|
|
+ [this, request]()
|
|
|
+ {
|
|
|
+ return this->setJobUser(request);
|
|
|
+ });
|
|
|
+
|
|
|
+ asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
|
+ return task->get_future();
|
|
|
+}
|
|
|
+
|
|
|
+EHPCClient::ListClustersOutcome EHPCClient::listClusters(const ListClustersRequest &request) const
|
|
|
+{
|
|
|
+ auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
|
+ if (!endpointOutcome.isSuccess())
|
|
|
+ return ListClustersOutcome(endpointOutcome.error());
|
|
|
+
|
|
|
+ auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
+
|
|
|
+ if (outcome.isSuccess())
|
|
|
+ return ListClustersOutcome(ListClustersResult(outcome.result()));
|
|
|
+ else
|
|
|
+ return ListClustersOutcome(outcome.error());
|
|
|
+}
|
|
|
+
|
|
|
+void EHPCClient::listClustersAsync(const ListClustersRequest& request, const ListClustersAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
|
{
|
|
|
- auto task = std::make_shared<std::packaged_task<DeleteJobsOutcome()>>(
|
|
|
+ auto fn = [this, request, handler, context]()
|
|
|
+ {
|
|
|
+ handler(this, request, listClusters(request), context);
|
|
|
+ };
|
|
|
+
|
|
|
+ asyncExecute(new Runnable(fn));
|
|
|
+}
|
|
|
+
|
|
|
+EHPCClient::ListClustersOutcomeCallable EHPCClient::listClustersCallable(const ListClustersRequest &request) const
|
|
|
+{
|
|
|
+ auto task = std::make_shared<std::packaged_task<ListClustersOutcome()>>(
|
|
|
[this, request]()
|
|
|
{
|
|
|
- return this->deleteJobs(request);
|
|
|
+ return this->listClusters(request);
|
|
|
});
|
|
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
|
return task->get_future();
|
|
|
}
|
|
|
|
|
|
-EHPCClient::DeleteNodesOutcome EHPCClient::deleteNodes(const DeleteNodesRequest &request) const
|
|
|
+EHPCClient::SubmitJobOutcome EHPCClient::submitJob(const SubmitJobRequest &request) const
|
|
|
{
|
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
|
if (!endpointOutcome.isSuccess())
|
|
|
- return DeleteNodesOutcome(endpointOutcome.error());
|
|
|
+ return SubmitJobOutcome(endpointOutcome.error());
|
|
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
|
|
if (outcome.isSuccess())
|
|
|
- return DeleteNodesOutcome(DeleteNodesResult(outcome.result()));
|
|
|
+ return SubmitJobOutcome(SubmitJobResult(outcome.result()));
|
|
|
else
|
|
|
- return DeleteNodesOutcome(outcome.error());
|
|
|
+ return SubmitJobOutcome(outcome.error());
|
|
|
}
|
|
|
|
|
|
-void EHPCClient::deleteNodesAsync(const DeleteNodesRequest& request, const DeleteNodesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
|
+void EHPCClient::submitJobAsync(const SubmitJobRequest& request, const SubmitJobAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
|
{
|
|
|
auto fn = [this, request, handler, context]()
|
|
|
{
|
|
|
- handler(this, request, deleteNodes(request), context);
|
|
|
+ handler(this, request, submitJob(request), context);
|
|
|
};
|
|
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
|
}
|
|
|
|
|
|
-EHPCClient::DeleteNodesOutcomeCallable EHPCClient::deleteNodesCallable(const DeleteNodesRequest &request) const
|
|
|
+EHPCClient::SubmitJobOutcomeCallable EHPCClient::submitJobCallable(const SubmitJobRequest &request) const
|
|
|
{
|
|
|
- auto task = std::make_shared<std::packaged_task<DeleteNodesOutcome()>>(
|
|
|
+ auto task = std::make_shared<std::packaged_task<SubmitJobOutcome()>>(
|
|
|
[this, request]()
|
|
|
{
|
|
|
- return this->deleteNodes(request);
|
|
|
+ return this->submitJob(request);
|
|
|
});
|
|
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
|
return task->get_future();
|
|
|
}
|
|
|
|
|
|
-EHPCClient::ListJobsOutcome EHPCClient::listJobs(const ListJobsRequest &request) const
|
|
|
+EHPCClient::ListRegionsOutcome EHPCClient::listRegions(const ListRegionsRequest &request) const
|
|
|
{
|
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
|
if (!endpointOutcome.isSuccess())
|
|
|
- return ListJobsOutcome(endpointOutcome.error());
|
|
|
+ return ListRegionsOutcome(endpointOutcome.error());
|
|
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
|
|
if (outcome.isSuccess())
|
|
|
- return ListJobsOutcome(ListJobsResult(outcome.result()));
|
|
|
+ return ListRegionsOutcome(ListRegionsResult(outcome.result()));
|
|
|
else
|
|
|
- return ListJobsOutcome(outcome.error());
|
|
|
+ return ListRegionsOutcome(outcome.error());
|
|
|
}
|
|
|
|
|
|
-void EHPCClient::listJobsAsync(const ListJobsRequest& request, const ListJobsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
|
+void EHPCClient::listRegionsAsync(const ListRegionsRequest& request, const ListRegionsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
|
{
|
|
|
auto fn = [this, request, handler, context]()
|
|
|
{
|
|
|
- handler(this, request, listJobs(request), context);
|
|
|
+ handler(this, request, listRegions(request), context);
|
|
|
};
|
|
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
|
}
|
|
|
|
|
|
-EHPCClient::ListJobsOutcomeCallable EHPCClient::listJobsCallable(const ListJobsRequest &request) const
|
|
|
+EHPCClient::ListRegionsOutcomeCallable EHPCClient::listRegionsCallable(const ListRegionsRequest &request) const
|
|
|
{
|
|
|
- auto task = std::make_shared<std::packaged_task<ListJobsOutcome()>>(
|
|
|
+ auto task = std::make_shared<std::packaged_task<ListRegionsOutcome()>>(
|
|
|
[this, request]()
|
|
|
{
|
|
|
- return this->listJobs(request);
|
|
|
+ return this->listRegions(request);
|
|
|
});
|
|
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
|
return task->get_future();
|
|
|
}
|
|
|
|
|
|
-EHPCClient::CreateClusterOutcome EHPCClient::createCluster(const CreateClusterRequest &request) const
|
|
|
+EHPCClient::DescribeAutoScaleConfigOutcome EHPCClient::describeAutoScaleConfig(const DescribeAutoScaleConfigRequest &request) const
|
|
|
{
|
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
|
if (!endpointOutcome.isSuccess())
|
|
|
- return CreateClusterOutcome(endpointOutcome.error());
|
|
|
+ return DescribeAutoScaleConfigOutcome(endpointOutcome.error());
|
|
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
|
|
if (outcome.isSuccess())
|
|
|
- return CreateClusterOutcome(CreateClusterResult(outcome.result()));
|
|
|
+ return DescribeAutoScaleConfigOutcome(DescribeAutoScaleConfigResult(outcome.result()));
|
|
|
else
|
|
|
- return CreateClusterOutcome(outcome.error());
|
|
|
+ return DescribeAutoScaleConfigOutcome(outcome.error());
|
|
|
}
|
|
|
|
|
|
-void EHPCClient::createClusterAsync(const CreateClusterRequest& request, const CreateClusterAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
|
+void EHPCClient::describeAutoScaleConfigAsync(const DescribeAutoScaleConfigRequest& request, const DescribeAutoScaleConfigAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
|
{
|
|
|
auto fn = [this, request, handler, context]()
|
|
|
{
|
|
|
- handler(this, request, createCluster(request), context);
|
|
|
+ handler(this, request, describeAutoScaleConfig(request), context);
|
|
|
};
|
|
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
|
}
|
|
|
|
|
|
-EHPCClient::CreateClusterOutcomeCallable EHPCClient::createClusterCallable(const CreateClusterRequest &request) const
|
|
|
+EHPCClient::DescribeAutoScaleConfigOutcomeCallable EHPCClient::describeAutoScaleConfigCallable(const DescribeAutoScaleConfigRequest &request) const
|
|
|
{
|
|
|
- auto task = std::make_shared<std::packaged_task<CreateClusterOutcome()>>(
|
|
|
+ auto task = std::make_shared<std::packaged_task<DescribeAutoScaleConfigOutcome()>>(
|
|
|
[this, request]()
|
|
|
{
|
|
|
- return this->createCluster(request);
|
|
|
+ return this->describeAutoScaleConfig(request);
|
|
|
});
|
|
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
|
return task->get_future();
|
|
|
}
|
|
|
|
|
|
-EHPCClient::ModifyUserPasswordsOutcome EHPCClient::modifyUserPasswords(const ModifyUserPasswordsRequest &request) const
|
|
|
+EHPCClient::RerunJobsOutcome EHPCClient::rerunJobs(const RerunJobsRequest &request) const
|
|
|
{
|
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
|
if (!endpointOutcome.isSuccess())
|
|
|
- return ModifyUserPasswordsOutcome(endpointOutcome.error());
|
|
|
+ return RerunJobsOutcome(endpointOutcome.error());
|
|
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
|
|
if (outcome.isSuccess())
|
|
|
- return ModifyUserPasswordsOutcome(ModifyUserPasswordsResult(outcome.result()));
|
|
|
+ return RerunJobsOutcome(RerunJobsResult(outcome.result()));
|
|
|
else
|
|
|
- return ModifyUserPasswordsOutcome(outcome.error());
|
|
|
+ return RerunJobsOutcome(outcome.error());
|
|
|
}
|
|
|
|
|
|
-void EHPCClient::modifyUserPasswordsAsync(const ModifyUserPasswordsRequest& request, const ModifyUserPasswordsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
|
+void EHPCClient::rerunJobsAsync(const RerunJobsRequest& request, const RerunJobsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
|
{
|
|
|
auto fn = [this, request, handler, context]()
|
|
|
{
|
|
|
- handler(this, request, modifyUserPasswords(request), context);
|
|
|
+ handler(this, request, rerunJobs(request), context);
|
|
|
};
|
|
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
|
}
|
|
|
|
|
|
-EHPCClient::ModifyUserPasswordsOutcomeCallable EHPCClient::modifyUserPasswordsCallable(const ModifyUserPasswordsRequest &request) const
|
|
|
+EHPCClient::RerunJobsOutcomeCallable EHPCClient::rerunJobsCallable(const RerunJobsRequest &request) const
|
|
|
{
|
|
|
- auto task = std::make_shared<std::packaged_task<ModifyUserPasswordsOutcome()>>(
|
|
|
+ auto task = std::make_shared<std::packaged_task<RerunJobsOutcome()>>(
|
|
|
[this, request]()
|
|
|
{
|
|
|
- return this->modifyUserPasswords(request);
|
|
|
+ return this->rerunJobs(request);
|
|
|
+ });
|
|
|
+
|
|
|
+ asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
|
+ return task->get_future();
|
|
|
+}
|
|
|
+
|
|
|
+EHPCClient::EditJobTemplateOutcome EHPCClient::editJobTemplate(const EditJobTemplateRequest &request) const
|
|
|
+{
|
|
|
+ auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
|
+ if (!endpointOutcome.isSuccess())
|
|
|
+ return EditJobTemplateOutcome(endpointOutcome.error());
|
|
|
+
|
|
|
+ auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
+
|
|
|
+ if (outcome.isSuccess())
|
|
|
+ return EditJobTemplateOutcome(EditJobTemplateResult(outcome.result()));
|
|
|
+ else
|
|
|
+ return EditJobTemplateOutcome(outcome.error());
|
|
|
+}
|
|
|
+
|
|
|
+void EHPCClient::editJobTemplateAsync(const EditJobTemplateRequest& request, const EditJobTemplateAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
|
+{
|
|
|
+ auto fn = [this, request, handler, context]()
|
|
|
+ {
|
|
|
+ handler(this, request, editJobTemplate(request), context);
|
|
|
+ };
|
|
|
+
|
|
|
+ asyncExecute(new Runnable(fn));
|
|
|
+}
|
|
|
+
|
|
|
+EHPCClient::EditJobTemplateOutcomeCallable EHPCClient::editJobTemplateCallable(const EditJobTemplateRequest &request) const
|
|
|
+{
|
|
|
+ auto task = std::make_shared<std::packaged_task<EditJobTemplateOutcome()>>(
|
|
|
+ [this, request]()
|
|
|
+ {
|
|
|
+ return this->editJobTemplate(request);
|
|
|
+ });
|
|
|
+
|
|
|
+ asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
|
+ return task->get_future();
|
|
|
+}
|
|
|
+
|
|
|
+EHPCClient::ListPreferredEcsTypesOutcome EHPCClient::listPreferredEcsTypes(const ListPreferredEcsTypesRequest &request) const
|
|
|
+{
|
|
|
+ auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
|
+ if (!endpointOutcome.isSuccess())
|
|
|
+ return ListPreferredEcsTypesOutcome(endpointOutcome.error());
|
|
|
+
|
|
|
+ auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
+
|
|
|
+ if (outcome.isSuccess())
|
|
|
+ return ListPreferredEcsTypesOutcome(ListPreferredEcsTypesResult(outcome.result()));
|
|
|
+ else
|
|
|
+ return ListPreferredEcsTypesOutcome(outcome.error());
|
|
|
+}
|
|
|
+
|
|
|
+void EHPCClient::listPreferredEcsTypesAsync(const ListPreferredEcsTypesRequest& request, const ListPreferredEcsTypesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
|
+{
|
|
|
+ auto fn = [this, request, handler, context]()
|
|
|
+ {
|
|
|
+ handler(this, request, listPreferredEcsTypes(request), context);
|
|
|
+ };
|
|
|
+
|
|
|
+ asyncExecute(new Runnable(fn));
|
|
|
+}
|
|
|
+
|
|
|
+EHPCClient::ListPreferredEcsTypesOutcomeCallable EHPCClient::listPreferredEcsTypesCallable(const ListPreferredEcsTypesRequest &request) const
|
|
|
+{
|
|
|
+ auto task = std::make_shared<std::packaged_task<ListPreferredEcsTypesOutcome()>>(
|
|
|
+ [this, request]()
|
|
|
+ {
|
|
|
+ return this->listPreferredEcsTypes(request);
|
|
|
+ });
|
|
|
+
|
|
|
+ asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
|
+ return task->get_future();
|
|
|
+}
|
|
|
+
|
|
|
+EHPCClient::AddContainerAppOutcome EHPCClient::addContainerApp(const AddContainerAppRequest &request) const
|
|
|
+{
|
|
|
+ auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
|
+ if (!endpointOutcome.isSuccess())
|
|
|
+ return AddContainerAppOutcome(endpointOutcome.error());
|
|
|
+
|
|
|
+ auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
+
|
|
|
+ if (outcome.isSuccess())
|
|
|
+ return AddContainerAppOutcome(AddContainerAppResult(outcome.result()));
|
|
|
+ else
|
|
|
+ return AddContainerAppOutcome(outcome.error());
|
|
|
+}
|
|
|
+
|
|
|
+void EHPCClient::addContainerAppAsync(const AddContainerAppRequest& request, const AddContainerAppAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
|
+{
|
|
|
+ auto fn = [this, request, handler, context]()
|
|
|
+ {
|
|
|
+ handler(this, request, addContainerApp(request), context);
|
|
|
+ };
|
|
|
+
|
|
|
+ asyncExecute(new Runnable(fn));
|
|
|
+}
|
|
|
+
|
|
|
+EHPCClient::AddContainerAppOutcomeCallable EHPCClient::addContainerAppCallable(const AddContainerAppRequest &request) const
|
|
|
+{
|
|
|
+ auto task = std::make_shared<std::packaged_task<AddContainerAppOutcome()>>(
|
|
|
+ [this, request]()
|
|
|
+ {
|
|
|
+ return this->addContainerApp(request);
|
|
|
+ });
|
|
|
+
|
|
|
+ asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
|
+ return task->get_future();
|
|
|
+}
|
|
|
+
|
|
|
+EHPCClient::ListClusterLogsOutcome EHPCClient::listClusterLogs(const ListClusterLogsRequest &request) const
|
|
|
+{
|
|
|
+ auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
|
+ if (!endpointOutcome.isSuccess())
|
|
|
+ return ListClusterLogsOutcome(endpointOutcome.error());
|
|
|
+
|
|
|
+ auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
+
|
|
|
+ if (outcome.isSuccess())
|
|
|
+ return ListClusterLogsOutcome(ListClusterLogsResult(outcome.result()));
|
|
|
+ else
|
|
|
+ return ListClusterLogsOutcome(outcome.error());
|
|
|
+}
|
|
|
+
|
|
|
+void EHPCClient::listClusterLogsAsync(const ListClusterLogsRequest& request, const ListClusterLogsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
|
+{
|
|
|
+ auto fn = [this, request, handler, context]()
|
|
|
+ {
|
|
|
+ handler(this, request, listClusterLogs(request), context);
|
|
|
+ };
|
|
|
+
|
|
|
+ asyncExecute(new Runnable(fn));
|
|
|
+}
|
|
|
+
|
|
|
+EHPCClient::ListClusterLogsOutcomeCallable EHPCClient::listClusterLogsCallable(const ListClusterLogsRequest &request) const
|
|
|
+{
|
|
|
+ auto task = std::make_shared<std::packaged_task<ListClusterLogsOutcome()>>(
|
|
|
+ [this, request]()
|
|
|
+ {
|
|
|
+ return this->listClusterLogs(request);
|
|
|
+ });
|
|
|
+
|
|
|
+ asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
|
+ return task->get_future();
|
|
|
+}
|
|
|
+
|
|
|
+EHPCClient::RecoverClusterOutcome EHPCClient::recoverCluster(const RecoverClusterRequest &request) const
|
|
|
+{
|
|
|
+ auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
|
+ if (!endpointOutcome.isSuccess())
|
|
|
+ return RecoverClusterOutcome(endpointOutcome.error());
|
|
|
+
|
|
|
+ auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
+
|
|
|
+ if (outcome.isSuccess())
|
|
|
+ return RecoverClusterOutcome(RecoverClusterResult(outcome.result()));
|
|
|
+ else
|
|
|
+ return RecoverClusterOutcome(outcome.error());
|
|
|
+}
|
|
|
+
|
|
|
+void EHPCClient::recoverClusterAsync(const RecoverClusterRequest& request, const RecoverClusterAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
|
+{
|
|
|
+ auto fn = [this, request, handler, context]()
|
|
|
+ {
|
|
|
+ handler(this, request, recoverCluster(request), context);
|
|
|
+ };
|
|
|
+
|
|
|
+ asyncExecute(new Runnable(fn));
|
|
|
+}
|
|
|
+
|
|
|
+EHPCClient::RecoverClusterOutcomeCallable EHPCClient::recoverClusterCallable(const RecoverClusterRequest &request) const
|
|
|
+{
|
|
|
+ auto task = std::make_shared<std::packaged_task<RecoverClusterOutcome()>>(
|
|
|
+ [this, request]()
|
|
|
+ {
|
|
|
+ return this->recoverCluster(request);
|
|
|
});
|
|
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
haowei.yao