|
|
@@ -267,72 +267,72 @@ EHPCClient::DescribeClusterOutcomeCallable EHPCClient::describeClusterCallable(c
|
|
|
return task->get_future();
|
|
|
}
|
|
|
|
|
|
-EHPCClient::DescribeContainerAppOutcome EHPCClient::describeContainerApp(const DescribeContainerAppRequest &request) const
|
|
|
+EHPCClient::StopNodesOutcome EHPCClient::stopNodes(const StopNodesRequest &request) const
|
|
|
{
|
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
|
if (!endpointOutcome.isSuccess())
|
|
|
- return DescribeContainerAppOutcome(endpointOutcome.error());
|
|
|
+ return StopNodesOutcome(endpointOutcome.error());
|
|
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
|
|
if (outcome.isSuccess())
|
|
|
- return DescribeContainerAppOutcome(DescribeContainerAppResult(outcome.result()));
|
|
|
+ return StopNodesOutcome(StopNodesResult(outcome.result()));
|
|
|
else
|
|
|
- return DescribeContainerAppOutcome(outcome.error());
|
|
|
+ return StopNodesOutcome(outcome.error());
|
|
|
}
|
|
|
|
|
|
-void EHPCClient::describeContainerAppAsync(const DescribeContainerAppRequest& request, const DescribeContainerAppAsyncHandler& 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, describeContainerApp(request), context);
|
|
|
+ handler(this, request, stopNodes(request), context);
|
|
|
};
|
|
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
|
}
|
|
|
|
|
|
-EHPCClient::DescribeContainerAppOutcomeCallable EHPCClient::describeContainerAppCallable(const DescribeContainerAppRequest &request) const
|
|
|
+EHPCClient::StopNodesOutcomeCallable EHPCClient::stopNodesCallable(const StopNodesRequest &request) const
|
|
|
{
|
|
|
- auto task = std::make_shared<std::packaged_task<DescribeContainerAppOutcome()>>(
|
|
|
+ auto task = std::make_shared<std::packaged_task<StopNodesOutcome()>>(
|
|
|
[this, request]()
|
|
|
{
|
|
|
- return this->describeContainerApp(request);
|
|
|
+ return this->stopNodes(request);
|
|
|
});
|
|
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
|
return task->get_future();
|
|
|
}
|
|
|
|
|
|
-EHPCClient::StopNodesOutcome EHPCClient::stopNodes(const StopNodesRequest &request) const
|
|
|
+EHPCClient::DescribeContainerAppOutcome EHPCClient::describeContainerApp(const DescribeContainerAppRequest &request) const
|
|
|
{
|
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
|
if (!endpointOutcome.isSuccess())
|
|
|
- return StopNodesOutcome(endpointOutcome.error());
|
|
|
+ return DescribeContainerAppOutcome(endpointOutcome.error());
|
|
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
|
|
if (outcome.isSuccess())
|
|
|
- return StopNodesOutcome(StopNodesResult(outcome.result()));
|
|
|
+ return DescribeContainerAppOutcome(DescribeContainerAppResult(outcome.result()));
|
|
|
else
|
|
|
- return StopNodesOutcome(outcome.error());
|
|
|
+ return DescribeContainerAppOutcome(outcome.error());
|
|
|
}
|
|
|
|
|
|
-void EHPCClient::stopNodesAsync(const StopNodesRequest& request, const StopNodesAsyncHandler& 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, stopNodes(request), context);
|
|
|
+ handler(this, request, describeContainerApp(request), context);
|
|
|
};
|
|
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
|
}
|
|
|
|
|
|
-EHPCClient::StopNodesOutcomeCallable EHPCClient::stopNodesCallable(const StopNodesRequest &request) const
|
|
|
+EHPCClient::DescribeContainerAppOutcomeCallable EHPCClient::describeContainerAppCallable(const DescribeContainerAppRequest &request) const
|
|
|
{
|
|
|
- auto task = std::make_shared<std::packaged_task<StopNodesOutcome()>>(
|
|
|
+ auto task = std::make_shared<std::packaged_task<DescribeContainerAppOutcome()>>(
|
|
|
[this, request]()
|
|
|
{
|
|
|
- return this->stopNodes(request);
|
|
|
+ return this->describeContainerApp(request);
|
|
|
});
|
|
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
|
@@ -915,72 +915,72 @@ EHPCClient::GetCloudMetricLogsOutcomeCallable EHPCClient::getCloudMetricLogsCall
|
|
|
return task->get_future();
|
|
|
}
|
|
|
|
|
|
-EHPCClient::GetHybridClusterConfigOutcome EHPCClient::getHybridClusterConfig(const GetHybridClusterConfigRequest &request) const
|
|
|
+EHPCClient::CreateJobTemplateOutcome EHPCClient::createJobTemplate(const CreateJobTemplateRequest &request) const
|
|
|
{
|
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
|
if (!endpointOutcome.isSuccess())
|
|
|
- return GetHybridClusterConfigOutcome(endpointOutcome.error());
|
|
|
+ return CreateJobTemplateOutcome(endpointOutcome.error());
|
|
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
|
|
if (outcome.isSuccess())
|
|
|
- return GetHybridClusterConfigOutcome(GetHybridClusterConfigResult(outcome.result()));
|
|
|
+ return CreateJobTemplateOutcome(CreateJobTemplateResult(outcome.result()));
|
|
|
else
|
|
|
- return GetHybridClusterConfigOutcome(outcome.error());
|
|
|
+ return CreateJobTemplateOutcome(outcome.error());
|
|
|
}
|
|
|
|
|
|
-void EHPCClient::getHybridClusterConfigAsync(const GetHybridClusterConfigRequest& request, const GetHybridClusterConfigAsyncHandler& 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, getHybridClusterConfig(request), context);
|
|
|
+ handler(this, request, createJobTemplate(request), context);
|
|
|
};
|
|
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
|
}
|
|
|
|
|
|
-EHPCClient::GetHybridClusterConfigOutcomeCallable EHPCClient::getHybridClusterConfigCallable(const GetHybridClusterConfigRequest &request) const
|
|
|
+EHPCClient::CreateJobTemplateOutcomeCallable EHPCClient::createJobTemplateCallable(const CreateJobTemplateRequest &request) const
|
|
|
{
|
|
|
- auto task = std::make_shared<std::packaged_task<GetHybridClusterConfigOutcome()>>(
|
|
|
+ auto task = std::make_shared<std::packaged_task<CreateJobTemplateOutcome()>>(
|
|
|
[this, request]()
|
|
|
{
|
|
|
- return this->getHybridClusterConfig(request);
|
|
|
+ return this->createJobTemplate(request);
|
|
|
});
|
|
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
|
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)(); }));
|
|
|
@@ -1419,72 +1419,72 @@ EHPCClient::QueryServicePackAndPriceOutcomeCallable EHPCClient::queryServicePack
|
|
|
return task->get_future();
|
|
|
}
|
|
|
|
|
|
-EHPCClient::DeleteContainerAppsOutcome EHPCClient::deleteContainerApps(const DeleteContainerAppsRequest &request) const
|
|
|
+EHPCClient::ListVolumesOutcome EHPCClient::listVolumes(const ListVolumesRequest &request) const
|
|
|
{
|
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
|
if (!endpointOutcome.isSuccess())
|
|
|
- return DeleteContainerAppsOutcome(endpointOutcome.error());
|
|
|
+ return ListVolumesOutcome(endpointOutcome.error());
|
|
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
|
|
if (outcome.isSuccess())
|
|
|
- return DeleteContainerAppsOutcome(DeleteContainerAppsResult(outcome.result()));
|
|
|
+ return ListVolumesOutcome(ListVolumesResult(outcome.result()));
|
|
|
else
|
|
|
- return DeleteContainerAppsOutcome(outcome.error());
|
|
|
+ return ListVolumesOutcome(outcome.error());
|
|
|
}
|
|
|
|
|
|
-void EHPCClient::deleteContainerAppsAsync(const DeleteContainerAppsRequest& request, const DeleteContainerAppsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
|
+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, deleteContainerApps(request), context);
|
|
|
+ handler(this, request, listVolumes(request), context);
|
|
|
};
|
|
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
|
}
|
|
|
|
|
|
-EHPCClient::DeleteContainerAppsOutcomeCallable EHPCClient::deleteContainerAppsCallable(const DeleteContainerAppsRequest &request) const
|
|
|
+EHPCClient::ListVolumesOutcomeCallable EHPCClient::listVolumesCallable(const ListVolumesRequest &request) const
|
|
|
{
|
|
|
- auto task = std::make_shared<std::packaged_task<DeleteContainerAppsOutcome()>>(
|
|
|
+ auto task = std::make_shared<std::packaged_task<ListVolumesOutcome()>>(
|
|
|
[this, request]()
|
|
|
{
|
|
|
- return this->deleteContainerApps(request);
|
|
|
+ return this->listVolumes(request);
|
|
|
});
|
|
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
|
return task->get_future();
|
|
|
}
|
|
|
|
|
|
-EHPCClient::ListVolumesOutcome EHPCClient::listVolumes(const ListVolumesRequest &request) const
|
|
|
+EHPCClient::DeleteContainerAppsOutcome EHPCClient::deleteContainerApps(const DeleteContainerAppsRequest &request) const
|
|
|
{
|
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
|
if (!endpointOutcome.isSuccess())
|
|
|
- return ListVolumesOutcome(endpointOutcome.error());
|
|
|
+ return DeleteContainerAppsOutcome(endpointOutcome.error());
|
|
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
|
|
if (outcome.isSuccess())
|
|
|
- return ListVolumesOutcome(ListVolumesResult(outcome.result()));
|
|
|
+ return DeleteContainerAppsOutcome(DeleteContainerAppsResult(outcome.result()));
|
|
|
else
|
|
|
- return ListVolumesOutcome(outcome.error());
|
|
|
+ return DeleteContainerAppsOutcome(outcome.error());
|
|
|
}
|
|
|
|
|
|
-void EHPCClient::listVolumesAsync(const ListVolumesRequest& request, const ListVolumesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
|
+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, listVolumes(request), context);
|
|
|
+ handler(this, request, deleteContainerApps(request), context);
|
|
|
};
|
|
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
|
}
|
|
|
|
|
|
-EHPCClient::ListVolumesOutcomeCallable EHPCClient::listVolumesCallable(const ListVolumesRequest &request) const
|
|
|
+EHPCClient::DeleteContainerAppsOutcomeCallable EHPCClient::deleteContainerAppsCallable(const DeleteContainerAppsRequest &request) const
|
|
|
{
|
|
|
- auto task = std::make_shared<std::packaged_task<ListVolumesOutcome()>>(
|
|
|
+ auto task = std::make_shared<std::packaged_task<DeleteContainerAppsOutcome()>>(
|
|
|
[this, request]()
|
|
|
{
|
|
|
- return this->listVolumes(request);
|
|
|
+ return this->deleteContainerApps(request);
|
|
|
});
|
|
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
|
@@ -1923,72 +1923,72 @@ EHPCClient::InstallSoftwareOutcomeCallable EHPCClient::installSoftwareCallable(c
|
|
|
return task->get_future();
|
|
|
}
|
|
|
|
|
|
-EHPCClient::MountNFSOutcome EHPCClient::mountNFS(const MountNFSRequest &request) const
|
|
|
+EHPCClient::ListAvailableEcsTypesOutcome EHPCClient::listAvailableEcsTypes(const ListAvailableEcsTypesRequest &request) const
|
|
|
{
|
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
|
if (!endpointOutcome.isSuccess())
|
|
|
- return MountNFSOutcome(endpointOutcome.error());
|
|
|
+ return ListAvailableEcsTypesOutcome(endpointOutcome.error());
|
|
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
|
|
if (outcome.isSuccess())
|
|
|
- return MountNFSOutcome(MountNFSResult(outcome.result()));
|
|
|
+ return ListAvailableEcsTypesOutcome(ListAvailableEcsTypesResult(outcome.result()));
|
|
|
else
|
|
|
- return MountNFSOutcome(outcome.error());
|
|
|
+ return ListAvailableEcsTypesOutcome(outcome.error());
|
|
|
}
|
|
|
|
|
|
-void EHPCClient::mountNFSAsync(const MountNFSRequest& request, const MountNFSAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
|
+void EHPCClient::listAvailableEcsTypesAsync(const ListAvailableEcsTypesRequest& request, const ListAvailableEcsTypesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
|
{
|
|
|
auto fn = [this, request, handler, context]()
|
|
|
{
|
|
|
- handler(this, request, mountNFS(request), context);
|
|
|
+ handler(this, request, listAvailableEcsTypes(request), context);
|
|
|
};
|
|
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
|
}
|
|
|
|
|
|
-EHPCClient::MountNFSOutcomeCallable EHPCClient::mountNFSCallable(const MountNFSRequest &request) const
|
|
|
+EHPCClient::ListAvailableEcsTypesOutcomeCallable EHPCClient::listAvailableEcsTypesCallable(const ListAvailableEcsTypesRequest &request) const
|
|
|
{
|
|
|
- auto task = std::make_shared<std::packaged_task<MountNFSOutcome()>>(
|
|
|
+ auto task = std::make_shared<std::packaged_task<ListAvailableEcsTypesOutcome()>>(
|
|
|
[this, request]()
|
|
|
{
|
|
|
- return this->mountNFS(request);
|
|
|
+ return this->listAvailableEcsTypes(request);
|
|
|
});
|
|
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
|
return task->get_future();
|
|
|
}
|
|
|
|
|
|
-EHPCClient::ListAvailableEcsTypesOutcome EHPCClient::listAvailableEcsTypes(const ListAvailableEcsTypesRequest &request) const
|
|
|
+EHPCClient::MountNFSOutcome EHPCClient::mountNFS(const MountNFSRequest &request) const
|
|
|
{
|
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
|
if (!endpointOutcome.isSuccess())
|
|
|
- return ListAvailableEcsTypesOutcome(endpointOutcome.error());
|
|
|
+ return MountNFSOutcome(endpointOutcome.error());
|
|
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
|
|
if (outcome.isSuccess())
|
|
|
- return ListAvailableEcsTypesOutcome(ListAvailableEcsTypesResult(outcome.result()));
|
|
|
+ return MountNFSOutcome(MountNFSResult(outcome.result()));
|
|
|
else
|
|
|
- return ListAvailableEcsTypesOutcome(outcome.error());
|
|
|
+ return MountNFSOutcome(outcome.error());
|
|
|
}
|
|
|
|
|
|
-void EHPCClient::listAvailableEcsTypesAsync(const ListAvailableEcsTypesRequest& request, const ListAvailableEcsTypesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
|
+void EHPCClient::mountNFSAsync(const MountNFSRequest& request, const MountNFSAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
|
{
|
|
|
auto fn = [this, request, handler, context]()
|
|
|
{
|
|
|
- handler(this, request, listAvailableEcsTypes(request), context);
|
|
|
+ handler(this, request, mountNFS(request), context);
|
|
|
};
|
|
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
|
}
|
|
|
|
|
|
-EHPCClient::ListAvailableEcsTypesOutcomeCallable EHPCClient::listAvailableEcsTypesCallable(const ListAvailableEcsTypesRequest &request) const
|
|
|
+EHPCClient::MountNFSOutcomeCallable EHPCClient::mountNFSCallable(const MountNFSRequest &request) const
|
|
|
{
|
|
|
- auto task = std::make_shared<std::packaged_task<ListAvailableEcsTypesOutcome()>>(
|
|
|
+ auto task = std::make_shared<std::packaged_task<MountNFSOutcome()>>(
|
|
|
[this, request]()
|
|
|
{
|
|
|
- return this->listAvailableEcsTypes(request);
|
|
|
+ return this->mountNFS(request);
|
|
|
});
|
|
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
|
@@ -2175,144 +2175,144 @@ EHPCClient::StartGWSInstanceOutcomeCallable EHPCClient::startGWSInstanceCallable
|
|
|
return task->get_future();
|
|
|
}
|
|
|
|
|
|
-EHPCClient::ListInvocationResultsOutcome EHPCClient::listInvocationResults(const ListInvocationResultsRequest &request) const
|
|
|
+EHPCClient::SetAutoScaleConfigOutcome EHPCClient::setAutoScaleConfig(const SetAutoScaleConfigRequest &request) const
|
|
|
{
|
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
|
if (!endpointOutcome.isSuccess())
|
|
|
- return ListInvocationResultsOutcome(endpointOutcome.error());
|
|
|
+ return SetAutoScaleConfigOutcome(endpointOutcome.error());
|
|
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
|
|
if (outcome.isSuccess())
|
|
|
- return ListInvocationResultsOutcome(ListInvocationResultsResult(outcome.result()));
|
|
|
+ return SetAutoScaleConfigOutcome(SetAutoScaleConfigResult(outcome.result()));
|
|
|
else
|
|
|
- return ListInvocationResultsOutcome(outcome.error());
|
|
|
+ return SetAutoScaleConfigOutcome(outcome.error());
|
|
|
}
|
|
|
|
|
|
-void EHPCClient::listInvocationResultsAsync(const ListInvocationResultsRequest& request, const ListInvocationResultsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
|
+void EHPCClient::setAutoScaleConfigAsync(const SetAutoScaleConfigRequest& request, const SetAutoScaleConfigAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
|
{
|
|
|
auto fn = [this, request, handler, context]()
|
|
|
{
|
|
|
- handler(this, request, listInvocationResults(request), context);
|
|
|
+ handler(this, request, setAutoScaleConfig(request), context);
|
|
|
};
|
|
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
|
}
|
|
|
|
|
|
-EHPCClient::ListInvocationResultsOutcomeCallable EHPCClient::listInvocationResultsCallable(const ListInvocationResultsRequest &request) const
|
|
|
+EHPCClient::SetAutoScaleConfigOutcomeCallable EHPCClient::setAutoScaleConfigCallable(const SetAutoScaleConfigRequest &request) const
|
|
|
{
|
|
|
- auto task = std::make_shared<std::packaged_task<ListInvocationResultsOutcome()>>(
|
|
|
+ auto task = std::make_shared<std::packaged_task<SetAutoScaleConfigOutcome()>>(
|
|
|
[this, request]()
|
|
|
{
|
|
|
- return this->listInvocationResults(request);
|
|
|
+ return this->setAutoScaleConfig(request);
|
|
|
});
|
|
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
|
return task->get_future();
|
|
|
}
|
|
|
|
|
|
-EHPCClient::SetAutoScaleConfigOutcome EHPCClient::setAutoScaleConfig(const SetAutoScaleConfigRequest &request) const
|
|
|
+EHPCClient::ListInvocationResultsOutcome EHPCClient::listInvocationResults(const ListInvocationResultsRequest &request) const
|
|
|
{
|
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
|
if (!endpointOutcome.isSuccess())
|
|
|
- return SetAutoScaleConfigOutcome(endpointOutcome.error());
|
|
|
+ return ListInvocationResultsOutcome(endpointOutcome.error());
|
|
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
|
|
if (outcome.isSuccess())
|
|
|
- return SetAutoScaleConfigOutcome(SetAutoScaleConfigResult(outcome.result()));
|
|
|
+ return ListInvocationResultsOutcome(ListInvocationResultsResult(outcome.result()));
|
|
|
else
|
|
|
- return SetAutoScaleConfigOutcome(outcome.error());
|
|
|
+ return ListInvocationResultsOutcome(outcome.error());
|
|
|
}
|
|
|
|
|
|
-void EHPCClient::setAutoScaleConfigAsync(const SetAutoScaleConfigRequest& request, const SetAutoScaleConfigAsyncHandler& 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, setAutoScaleConfig(request), context);
|
|
|
+ handler(this, request, listInvocationResults(request), context);
|
|
|
};
|
|
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
|
}
|
|
|
|
|
|
-EHPCClient::SetAutoScaleConfigOutcomeCallable EHPCClient::setAutoScaleConfigCallable(const SetAutoScaleConfigRequest &request) const
|
|
|
+EHPCClient::ListInvocationResultsOutcomeCallable EHPCClient::listInvocationResultsCallable(const ListInvocationResultsRequest &request) const
|
|
|
{
|
|
|
- auto task = std::make_shared<std::packaged_task<SetAutoScaleConfigOutcome()>>(
|
|
|
+ auto task = std::make_shared<std::packaged_task<ListInvocationResultsOutcome()>>(
|
|
|
[this, request]()
|
|
|
{
|
|
|
- return this->setAutoScaleConfig(request);
|
|
|
+ return this->listInvocationResults(request);
|
|
|
});
|
|
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
|
return task->get_future();
|
|
|
}
|
|
|
|
|
|
-EHPCClient::AddNodesOutcome EHPCClient::addNodes(const AddNodesRequest &request) const
|
|
|
+EHPCClient::ListSoftwaresOutcome EHPCClient::listSoftwares(const ListSoftwaresRequest &request) const
|
|
|
{
|
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
|
if (!endpointOutcome.isSuccess())
|
|
|
- return AddNodesOutcome(endpointOutcome.error());
|
|
|
+ return ListSoftwaresOutcome(endpointOutcome.error());
|
|
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
|
|
if (outcome.isSuccess())
|
|
|
- return AddNodesOutcome(AddNodesResult(outcome.result()));
|
|
|
+ return ListSoftwaresOutcome(ListSoftwaresResult(outcome.result()));
|
|
|
else
|
|
|
- return AddNodesOutcome(outcome.error());
|
|
|
+ return ListSoftwaresOutcome(outcome.error());
|
|
|
}
|
|
|
|
|
|
-void EHPCClient::addNodesAsync(const AddNodesRequest& request, const AddNodesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
|
+void EHPCClient::listSoftwaresAsync(const ListSoftwaresRequest& request, const ListSoftwaresAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
|
{
|
|
|
auto fn = [this, request, handler, context]()
|
|
|
{
|
|
|
- handler(this, request, addNodes(request), context);
|
|
|
+ handler(this, request, listSoftwares(request), context);
|
|
|
};
|
|
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
|
}
|
|
|
|
|
|
-EHPCClient::AddNodesOutcomeCallable EHPCClient::addNodesCallable(const AddNodesRequest &request) const
|
|
|
+EHPCClient::ListSoftwaresOutcomeCallable EHPCClient::listSoftwaresCallable(const ListSoftwaresRequest &request) const
|
|
|
{
|
|
|
- auto task = std::make_shared<std::packaged_task<AddNodesOutcome()>>(
|
|
|
+ auto task = std::make_shared<std::packaged_task<ListSoftwaresOutcome()>>(
|
|
|
[this, request]()
|
|
|
{
|
|
|
- return this->addNodes(request);
|
|
|
+ return this->listSoftwares(request);
|
|
|
});
|
|
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
|
return task->get_future();
|
|
|
}
|
|
|
|
|
|
-EHPCClient::ListSoftwaresOutcome EHPCClient::listSoftwares(const ListSoftwaresRequest &request) const
|
|
|
+EHPCClient::AddNodesOutcome EHPCClient::addNodes(const AddNodesRequest &request) const
|
|
|
{
|
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
|
if (!endpointOutcome.isSuccess())
|
|
|
- return ListSoftwaresOutcome(endpointOutcome.error());
|
|
|
+ return AddNodesOutcome(endpointOutcome.error());
|
|
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
|
|
if (outcome.isSuccess())
|
|
|
- return ListSoftwaresOutcome(ListSoftwaresResult(outcome.result()));
|
|
|
+ return AddNodesOutcome(AddNodesResult(outcome.result()));
|
|
|
else
|
|
|
- return ListSoftwaresOutcome(outcome.error());
|
|
|
+ return AddNodesOutcome(outcome.error());
|
|
|
}
|
|
|
|
|
|
-void EHPCClient::listSoftwaresAsync(const ListSoftwaresRequest& request, const ListSoftwaresAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
|
+void EHPCClient::addNodesAsync(const AddNodesRequest& request, const AddNodesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
|
{
|
|
|
auto fn = [this, request, handler, context]()
|
|
|
{
|
|
|
- handler(this, request, listSoftwares(request), context);
|
|
|
+ handler(this, request, addNodes(request), context);
|
|
|
};
|
|
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
|
}
|
|
|
|
|
|
-EHPCClient::ListSoftwaresOutcomeCallable EHPCClient::listSoftwaresCallable(const ListSoftwaresRequest &request) const
|
|
|
+EHPCClient::AddNodesOutcomeCallable EHPCClient::addNodesCallable(const AddNodesRequest &request) const
|
|
|
{
|
|
|
- auto task = std::make_shared<std::packaged_task<ListSoftwaresOutcome()>>(
|
|
|
+ auto task = std::make_shared<std::packaged_task<AddNodesOutcome()>>(
|
|
|
[this, request]()
|
|
|
{
|
|
|
- return this->listSoftwares(request);
|
|
|
+ return this->addNodes(request);
|
|
|
});
|
|
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
|
@@ -2463,72 +2463,72 @@ EHPCClient::ModifyUserGroupsOutcomeCallable EHPCClient::modifyUserGroupsCallable
|
|
|
return task->get_future();
|
|
|
}
|
|
|
|
|
|
-EHPCClient::SetQueueOutcome EHPCClient::setQueue(const SetQueueRequest &request) const
|
|
|
+EHPCClient::StartClusterOutcome EHPCClient::startCluster(const StartClusterRequest &request) const
|
|
|
{
|
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
|
if (!endpointOutcome.isSuccess())
|
|
|
- return SetQueueOutcome(endpointOutcome.error());
|
|
|
+ return StartClusterOutcome(endpointOutcome.error());
|
|
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
|
|
if (outcome.isSuccess())
|
|
|
- return SetQueueOutcome(SetQueueResult(outcome.result()));
|
|
|
+ return StartClusterOutcome(StartClusterResult(outcome.result()));
|
|
|
else
|
|
|
- return SetQueueOutcome(outcome.error());
|
|
|
+ return StartClusterOutcome(outcome.error());
|
|
|
}
|
|
|
|
|
|
-void EHPCClient::setQueueAsync(const SetQueueRequest& request, const SetQueueAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
|
+void EHPCClient::startClusterAsync(const StartClusterRequest& request, const StartClusterAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
|
{
|
|
|
auto fn = [this, request, handler, context]()
|
|
|
{
|
|
|
- handler(this, request, setQueue(request), context);
|
|
|
+ handler(this, request, startCluster(request), context);
|
|
|
};
|
|
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
|
}
|
|
|
|
|
|
-EHPCClient::SetQueueOutcomeCallable EHPCClient::setQueueCallable(const SetQueueRequest &request) const
|
|
|
+EHPCClient::StartClusterOutcomeCallable EHPCClient::startClusterCallable(const StartClusterRequest &request) const
|
|
|
{
|
|
|
- auto task = std::make_shared<std::packaged_task<SetQueueOutcome()>>(
|
|
|
+ auto task = std::make_shared<std::packaged_task<StartClusterOutcome()>>(
|
|
|
[this, request]()
|
|
|
{
|
|
|
- return this->setQueue(request);
|
|
|
+ return this->startCluster(request);
|
|
|
});
|
|
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
|
return task->get_future();
|
|
|
}
|
|
|
|
|
|
-EHPCClient::StartClusterOutcome EHPCClient::startCluster(const StartClusterRequest &request) const
|
|
|
+EHPCClient::SetQueueOutcome EHPCClient::setQueue(const SetQueueRequest &request) const
|
|
|
{
|
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
|
if (!endpointOutcome.isSuccess())
|
|
|
- return StartClusterOutcome(endpointOutcome.error());
|
|
|
+ return SetQueueOutcome(endpointOutcome.error());
|
|
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
|
|
if (outcome.isSuccess())
|
|
|
- return StartClusterOutcome(StartClusterResult(outcome.result()));
|
|
|
+ return SetQueueOutcome(SetQueueResult(outcome.result()));
|
|
|
else
|
|
|
- return StartClusterOutcome(outcome.error());
|
|
|
+ return SetQueueOutcome(outcome.error());
|
|
|
}
|
|
|
|
|
|
-void EHPCClient::startClusterAsync(const StartClusterRequest& request, const StartClusterAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
|
+void EHPCClient::setQueueAsync(const SetQueueRequest& request, const SetQueueAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
|
{
|
|
|
auto fn = [this, request, handler, context]()
|
|
|
{
|
|
|
- handler(this, request, startCluster(request), context);
|
|
|
+ handler(this, request, setQueue(request), context);
|
|
|
};
|
|
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
|
}
|
|
|
|
|
|
-EHPCClient::StartClusterOutcomeCallable EHPCClient::startClusterCallable(const StartClusterRequest &request) const
|
|
|
+EHPCClient::SetQueueOutcomeCallable EHPCClient::setQueueCallable(const SetQueueRequest &request) const
|
|
|
{
|
|
|
- auto task = std::make_shared<std::packaged_task<StartClusterOutcome()>>(
|
|
|
+ auto task = std::make_shared<std::packaged_task<SetQueueOutcome()>>(
|
|
|
[this, request]()
|
|
|
{
|
|
|
- return this->startCluster(request);
|
|
|
+ return this->setQueue(request);
|
|
|
});
|
|
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
|
@@ -2571,36 +2571,36 @@ EHPCClient::ListCustomImagesOutcomeCallable EHPCClient::listCustomImagesCallable
|
|
|
return task->get_future();
|
|
|
}
|
|
|
|
|
|
-EHPCClient::CreateGWSClusterOutcome EHPCClient::createGWSCluster(const CreateGWSClusterRequest &request) const
|
|
|
+EHPCClient::ListJobTemplatesOutcome EHPCClient::listJobTemplates(const ListJobTemplatesRequest &request) const
|
|
|
{
|
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
|
if (!endpointOutcome.isSuccess())
|
|
|
- return CreateGWSClusterOutcome(endpointOutcome.error());
|
|
|
+ return ListJobTemplatesOutcome(endpointOutcome.error());
|
|
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
|
|
if (outcome.isSuccess())
|
|
|
- return CreateGWSClusterOutcome(CreateGWSClusterResult(outcome.result()));
|
|
|
+ return ListJobTemplatesOutcome(ListJobTemplatesResult(outcome.result()));
|
|
|
else
|
|
|
- return CreateGWSClusterOutcome(outcome.error());
|
|
|
+ return ListJobTemplatesOutcome(outcome.error());
|
|
|
}
|
|
|
|
|
|
-void EHPCClient::createGWSClusterAsync(const CreateGWSClusterRequest& request, const CreateGWSClusterAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
|
+void EHPCClient::listJobTemplatesAsync(const ListJobTemplatesRequest& request, const ListJobTemplatesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
|
{
|
|
|
auto fn = [this, request, handler, context]()
|
|
|
{
|
|
|
- handler(this, request, createGWSCluster(request), context);
|
|
|
+ handler(this, request, listJobTemplates(request), context);
|
|
|
};
|
|
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
|
}
|
|
|
|
|
|
-EHPCClient::CreateGWSClusterOutcomeCallable EHPCClient::createGWSClusterCallable(const CreateGWSClusterRequest &request) const
|
|
|
+EHPCClient::ListJobTemplatesOutcomeCallable EHPCClient::listJobTemplatesCallable(const ListJobTemplatesRequest &request) const
|
|
|
{
|
|
|
- auto task = std::make_shared<std::packaged_task<CreateGWSClusterOutcome()>>(
|
|
|
+ auto task = std::make_shared<std::packaged_task<ListJobTemplatesOutcome()>>(
|
|
|
[this, request]()
|
|
|
{
|
|
|
- return this->createGWSCluster(request);
|
|
|
+ return this->listJobTemplates(request);
|
|
|
});
|
|
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
|
@@ -2643,36 +2643,36 @@ EHPCClient::AddUsersOutcomeCallable EHPCClient::addUsersCallable(const AddUsersR
|
|
|
return task->get_future();
|
|
|
}
|
|
|
|
|
|
-EHPCClient::ListJobTemplatesOutcome EHPCClient::listJobTemplates(const ListJobTemplatesRequest &request) const
|
|
|
+EHPCClient::CreateGWSClusterOutcome EHPCClient::createGWSCluster(const CreateGWSClusterRequest &request) const
|
|
|
{
|
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
|
if (!endpointOutcome.isSuccess())
|
|
|
- return ListJobTemplatesOutcome(endpointOutcome.error());
|
|
|
+ return CreateGWSClusterOutcome(endpointOutcome.error());
|
|
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
|
|
if (outcome.isSuccess())
|
|
|
- return ListJobTemplatesOutcome(ListJobTemplatesResult(outcome.result()));
|
|
|
+ return CreateGWSClusterOutcome(CreateGWSClusterResult(outcome.result()));
|
|
|
else
|
|
|
- return ListJobTemplatesOutcome(outcome.error());
|
|
|
+ return CreateGWSClusterOutcome(outcome.error());
|
|
|
}
|
|
|
|
|
|
-void EHPCClient::listJobTemplatesAsync(const ListJobTemplatesRequest& request, const ListJobTemplatesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
|
+void EHPCClient::createGWSClusterAsync(const CreateGWSClusterRequest& request, const CreateGWSClusterAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
|
{
|
|
|
auto fn = [this, request, handler, context]()
|
|
|
{
|
|
|
- handler(this, request, listJobTemplates(request), context);
|
|
|
+ handler(this, request, createGWSCluster(request), context);
|
|
|
};
|
|
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
|
}
|
|
|
|
|
|
-EHPCClient::ListJobTemplatesOutcomeCallable EHPCClient::listJobTemplatesCallable(const ListJobTemplatesRequest &request) const
|
|
|
+EHPCClient::CreateGWSClusterOutcomeCallable EHPCClient::createGWSClusterCallable(const CreateGWSClusterRequest &request) const
|
|
|
{
|
|
|
- auto task = std::make_shared<std::packaged_task<ListJobTemplatesOutcome()>>(
|
|
|
+ auto task = std::make_shared<std::packaged_task<CreateGWSClusterOutcome()>>(
|
|
|
[this, request]()
|
|
|
{
|
|
|
- return this->listJobTemplates(request);
|
|
|
+ return this->createGWSCluster(request);
|
|
|
});
|
|
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
|
@@ -2931,108 +2931,108 @@ EHPCClient::StopVisualServiceOutcomeCallable EHPCClient::stopVisualServiceCallab
|
|
|
return task->get_future();
|
|
|
}
|
|
|
|
|
|
-EHPCClient::DescribeImageOutcome EHPCClient::describeImage(const DescribeImageRequest &request) const
|
|
|
+EHPCClient::CreateClusterOutcome EHPCClient::createCluster(const CreateClusterRequest &request) const
|
|
|
{
|
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
|
if (!endpointOutcome.isSuccess())
|
|
|
- return DescribeImageOutcome(endpointOutcome.error());
|
|
|
+ return CreateClusterOutcome(endpointOutcome.error());
|
|
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
|
|
if (outcome.isSuccess())
|
|
|
- return DescribeImageOutcome(DescribeImageResult(outcome.result()));
|
|
|
+ return CreateClusterOutcome(CreateClusterResult(outcome.result()));
|
|
|
else
|
|
|
- return DescribeImageOutcome(outcome.error());
|
|
|
+ return CreateClusterOutcome(outcome.error());
|
|
|
}
|
|
|
|
|
|
-void EHPCClient::describeImageAsync(const DescribeImageRequest& request, const DescribeImageAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
|
+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, describeImage(request), context);
|
|
|
+ handler(this, request, createCluster(request), context);
|
|
|
};
|
|
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
|
}
|
|
|
|
|
|
-EHPCClient::DescribeImageOutcomeCallable EHPCClient::describeImageCallable(const DescribeImageRequest &request) const
|
|
|
+EHPCClient::CreateClusterOutcomeCallable EHPCClient::createClusterCallable(const CreateClusterRequest &request) const
|
|
|
{
|
|
|
- auto task = std::make_shared<std::packaged_task<DescribeImageOutcome()>>(
|
|
|
+ auto task = std::make_shared<std::packaged_task<CreateClusterOutcome()>>(
|
|
|
[this, request]()
|
|
|
{
|
|
|
- return this->describeImage(request);
|
|
|
+ return this->createCluster(request);
|
|
|
});
|
|
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
|
return task->get_future();
|
|
|
}
|
|
|
|
|
|
-EHPCClient::CreateClusterOutcome EHPCClient::createCluster(const CreateClusterRequest &request) const
|
|
|
+EHPCClient::ModifyUserPasswordsOutcome EHPCClient::modifyUserPasswords(const ModifyUserPasswordsRequest &request) const
|
|
|
{
|
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
|
if (!endpointOutcome.isSuccess())
|
|
|
- return CreateClusterOutcome(endpointOutcome.error());
|
|
|
+ return ModifyUserPasswordsOutcome(endpointOutcome.error());
|
|
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
|
|
if (outcome.isSuccess())
|
|
|
- return CreateClusterOutcome(CreateClusterResult(outcome.result()));
|
|
|
+ return ModifyUserPasswordsOutcome(ModifyUserPasswordsResult(outcome.result()));
|
|
|
else
|
|
|
- return CreateClusterOutcome(outcome.error());
|
|
|
+ return ModifyUserPasswordsOutcome(outcome.error());
|
|
|
}
|
|
|
|
|
|
-void EHPCClient::createClusterAsync(const CreateClusterRequest& request, const CreateClusterAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
|
+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, createCluster(request), context);
|
|
|
+ handler(this, request, modifyUserPasswords(request), context);
|
|
|
};
|
|
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
|
}
|
|
|
|
|
|
-EHPCClient::CreateClusterOutcomeCallable EHPCClient::createClusterCallable(const CreateClusterRequest &request) const
|
|
|
+EHPCClient::ModifyUserPasswordsOutcomeCallable EHPCClient::modifyUserPasswordsCallable(const ModifyUserPasswordsRequest &request) const
|
|
|
{
|
|
|
- auto task = std::make_shared<std::packaged_task<CreateClusterOutcome()>>(
|
|
|
+ auto task = std::make_shared<std::packaged_task<ModifyUserPasswordsOutcome()>>(
|
|
|
[this, request]()
|
|
|
{
|
|
|
- return this->createCluster(request);
|
|
|
+ return this->modifyUserPasswords(request);
|
|
|
});
|
|
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
|
return task->get_future();
|
|
|
}
|
|
|
|
|
|
-EHPCClient::ModifyUserPasswordsOutcome EHPCClient::modifyUserPasswords(const ModifyUserPasswordsRequest &request) const
|
|
|
+EHPCClient::DescribeImageOutcome EHPCClient::describeImage(const DescribeImageRequest &request) const
|
|
|
{
|
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
|
if (!endpointOutcome.isSuccess())
|
|
|
- return ModifyUserPasswordsOutcome(endpointOutcome.error());
|
|
|
+ return DescribeImageOutcome(endpointOutcome.error());
|
|
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
|
|
if (outcome.isSuccess())
|
|
|
- return ModifyUserPasswordsOutcome(ModifyUserPasswordsResult(outcome.result()));
|
|
|
+ return DescribeImageOutcome(DescribeImageResult(outcome.result()));
|
|
|
else
|
|
|
- return ModifyUserPasswordsOutcome(outcome.error());
|
|
|
+ return DescribeImageOutcome(outcome.error());
|
|
|
}
|
|
|
|
|
|
-void EHPCClient::modifyUserPasswordsAsync(const ModifyUserPasswordsRequest& request, const ModifyUserPasswordsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
|
+void EHPCClient::describeImageAsync(const DescribeImageRequest& request, const DescribeImageAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
|
{
|
|
|
auto fn = [this, request, handler, context]()
|
|
|
{
|
|
|
- handler(this, request, modifyUserPasswords(request), context);
|
|
|
+ handler(this, request, describeImage(request), context);
|
|
|
};
|
|
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
|
}
|
|
|
|
|
|
-EHPCClient::ModifyUserPasswordsOutcomeCallable EHPCClient::modifyUserPasswordsCallable(const ModifyUserPasswordsRequest &request) const
|
|
|
+EHPCClient::DescribeImageOutcomeCallable EHPCClient::describeImageCallable(const DescribeImageRequest &request) const
|
|
|
{
|
|
|
- auto task = std::make_shared<std::packaged_task<ModifyUserPasswordsOutcome()>>(
|
|
|
+ auto task = std::make_shared<std::packaged_task<DescribeImageOutcome()>>(
|
|
|
[this, request]()
|
|
|
{
|
|
|
- return this->modifyUserPasswords(request);
|
|
|
+ return this->describeImage(request);
|
|
|
});
|
|
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
sdk-team