2142 lines
72 KiB
C++
2142 lines
72 KiB
C++
/*
|
|
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
|
|
*
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
* you may not use this file except in compliance with the License.
|
|
* You may obtain a copy of the License at
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
* See the License for the specific language governing permissions and
|
|
* limitations under the License.
|
|
*/
|
|
|
|
#include <alibabacloud/eas/EasClient.h>
|
|
#include <alibabacloud/core/SimpleCredentialsProvider.h>
|
|
|
|
using namespace AlibabaCloud;
|
|
using namespace AlibabaCloud::Location;
|
|
using namespace AlibabaCloud::Eas;
|
|
using namespace AlibabaCloud::Eas::Model;
|
|
|
|
namespace
|
|
{
|
|
const std::string SERVICE_NAME = "eas";
|
|
}
|
|
|
|
EasClient::EasClient(const Credentials &credentials, const ClientConfiguration &configuration) :
|
|
RoaServiceClient(SERVICE_NAME, std::make_shared<SimpleCredentialsProvider>(credentials), configuration)
|
|
{
|
|
auto locationClient = std::make_shared<LocationClient>(credentials, configuration);
|
|
endpointProvider_ = std::make_shared<EndpointProvider>(locationClient, configuration.regionId(), SERVICE_NAME, "eas");
|
|
}
|
|
|
|
EasClient::EasClient(const std::shared_ptr<CredentialsProvider>& credentialsProvider, const ClientConfiguration & configuration) :
|
|
RoaServiceClient(SERVICE_NAME, credentialsProvider, configuration)
|
|
{
|
|
auto locationClient = std::make_shared<LocationClient>(credentialsProvider, configuration);
|
|
endpointProvider_ = std::make_shared<EndpointProvider>(locationClient, configuration.regionId(), SERVICE_NAME, "eas");
|
|
}
|
|
|
|
EasClient::EasClient(const std::string & accessKeyId, const std::string & accessKeySecret, const ClientConfiguration & configuration) :
|
|
RoaServiceClient(SERVICE_NAME, std::make_shared<SimpleCredentialsProvider>(accessKeyId, accessKeySecret), configuration)
|
|
{
|
|
auto locationClient = std::make_shared<LocationClient>(accessKeyId, accessKeySecret, configuration);
|
|
endpointProvider_ = std::make_shared<EndpointProvider>(locationClient, configuration.regionId(), SERVICE_NAME, "eas");
|
|
}
|
|
|
|
EasClient::~EasClient()
|
|
{}
|
|
|
|
EasClient::CommitServiceOutcome EasClient::commitService(const CommitServiceRequest &request) const
|
|
{
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
if (!endpointOutcome.isSuccess())
|
|
return CommitServiceOutcome(endpointOutcome.error());
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
if (outcome.isSuccess())
|
|
return CommitServiceOutcome(CommitServiceResult(outcome.result()));
|
|
else
|
|
return CommitServiceOutcome(outcome.error());
|
|
}
|
|
|
|
void EasClient::commitServiceAsync(const CommitServiceRequest& request, const CommitServiceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
{
|
|
auto fn = [this, request, handler, context]()
|
|
{
|
|
handler(this, request, commitService(request), context);
|
|
};
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
}
|
|
|
|
EasClient::CommitServiceOutcomeCallable EasClient::commitServiceCallable(const CommitServiceRequest &request) const
|
|
{
|
|
auto task = std::make_shared<std::packaged_task<CommitServiceOutcome()>>(
|
|
[this, request]()
|
|
{
|
|
return this->commitService(request);
|
|
});
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
return task->get_future();
|
|
}
|
|
|
|
EasClient::CreateBenchmarkTaskOutcome EasClient::createBenchmarkTask(const CreateBenchmarkTaskRequest &request) const
|
|
{
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
if (!endpointOutcome.isSuccess())
|
|
return CreateBenchmarkTaskOutcome(endpointOutcome.error());
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
if (outcome.isSuccess())
|
|
return CreateBenchmarkTaskOutcome(CreateBenchmarkTaskResult(outcome.result()));
|
|
else
|
|
return CreateBenchmarkTaskOutcome(outcome.error());
|
|
}
|
|
|
|
void EasClient::createBenchmarkTaskAsync(const CreateBenchmarkTaskRequest& request, const CreateBenchmarkTaskAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
{
|
|
auto fn = [this, request, handler, context]()
|
|
{
|
|
handler(this, request, createBenchmarkTask(request), context);
|
|
};
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
}
|
|
|
|
EasClient::CreateBenchmarkTaskOutcomeCallable EasClient::createBenchmarkTaskCallable(const CreateBenchmarkTaskRequest &request) const
|
|
{
|
|
auto task = std::make_shared<std::packaged_task<CreateBenchmarkTaskOutcome()>>(
|
|
[this, request]()
|
|
{
|
|
return this->createBenchmarkTask(request);
|
|
});
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
return task->get_future();
|
|
}
|
|
|
|
EasClient::CreateResourceOutcome EasClient::createResource(const CreateResourceRequest &request) const
|
|
{
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
if (!endpointOutcome.isSuccess())
|
|
return CreateResourceOutcome(endpointOutcome.error());
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
if (outcome.isSuccess())
|
|
return CreateResourceOutcome(CreateResourceResult(outcome.result()));
|
|
else
|
|
return CreateResourceOutcome(outcome.error());
|
|
}
|
|
|
|
void EasClient::createResourceAsync(const CreateResourceRequest& request, const CreateResourceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
{
|
|
auto fn = [this, request, handler, context]()
|
|
{
|
|
handler(this, request, createResource(request), context);
|
|
};
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
}
|
|
|
|
EasClient::CreateResourceOutcomeCallable EasClient::createResourceCallable(const CreateResourceRequest &request) const
|
|
{
|
|
auto task = std::make_shared<std::packaged_task<CreateResourceOutcome()>>(
|
|
[this, request]()
|
|
{
|
|
return this->createResource(request);
|
|
});
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
return task->get_future();
|
|
}
|
|
|
|
EasClient::CreateResourceInstancesOutcome EasClient::createResourceInstances(const CreateResourceInstancesRequest &request) const
|
|
{
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
if (!endpointOutcome.isSuccess())
|
|
return CreateResourceInstancesOutcome(endpointOutcome.error());
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
if (outcome.isSuccess())
|
|
return CreateResourceInstancesOutcome(CreateResourceInstancesResult(outcome.result()));
|
|
else
|
|
return CreateResourceInstancesOutcome(outcome.error());
|
|
}
|
|
|
|
void EasClient::createResourceInstancesAsync(const CreateResourceInstancesRequest& request, const CreateResourceInstancesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
{
|
|
auto fn = [this, request, handler, context]()
|
|
{
|
|
handler(this, request, createResourceInstances(request), context);
|
|
};
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
}
|
|
|
|
EasClient::CreateResourceInstancesOutcomeCallable EasClient::createResourceInstancesCallable(const CreateResourceInstancesRequest &request) const
|
|
{
|
|
auto task = std::make_shared<std::packaged_task<CreateResourceInstancesOutcome()>>(
|
|
[this, request]()
|
|
{
|
|
return this->createResourceInstances(request);
|
|
});
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
return task->get_future();
|
|
}
|
|
|
|
EasClient::CreateResourceLogOutcome EasClient::createResourceLog(const CreateResourceLogRequest &request) const
|
|
{
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
if (!endpointOutcome.isSuccess())
|
|
return CreateResourceLogOutcome(endpointOutcome.error());
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
if (outcome.isSuccess())
|
|
return CreateResourceLogOutcome(CreateResourceLogResult(outcome.result()));
|
|
else
|
|
return CreateResourceLogOutcome(outcome.error());
|
|
}
|
|
|
|
void EasClient::createResourceLogAsync(const CreateResourceLogRequest& request, const CreateResourceLogAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
{
|
|
auto fn = [this, request, handler, context]()
|
|
{
|
|
handler(this, request, createResourceLog(request), context);
|
|
};
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
}
|
|
|
|
EasClient::CreateResourceLogOutcomeCallable EasClient::createResourceLogCallable(const CreateResourceLogRequest &request) const
|
|
{
|
|
auto task = std::make_shared<std::packaged_task<CreateResourceLogOutcome()>>(
|
|
[this, request]()
|
|
{
|
|
return this->createResourceLog(request);
|
|
});
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
return task->get_future();
|
|
}
|
|
|
|
EasClient::CreateServiceOutcome EasClient::createService(const CreateServiceRequest &request) const
|
|
{
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
if (!endpointOutcome.isSuccess())
|
|
return CreateServiceOutcome(endpointOutcome.error());
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
if (outcome.isSuccess())
|
|
return CreateServiceOutcome(CreateServiceResult(outcome.result()));
|
|
else
|
|
return CreateServiceOutcome(outcome.error());
|
|
}
|
|
|
|
void EasClient::createServiceAsync(const CreateServiceRequest& request, const CreateServiceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
{
|
|
auto fn = [this, request, handler, context]()
|
|
{
|
|
handler(this, request, createService(request), context);
|
|
};
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
}
|
|
|
|
EasClient::CreateServiceOutcomeCallable EasClient::createServiceCallable(const CreateServiceRequest &request) const
|
|
{
|
|
auto task = std::make_shared<std::packaged_task<CreateServiceOutcome()>>(
|
|
[this, request]()
|
|
{
|
|
return this->createService(request);
|
|
});
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
return task->get_future();
|
|
}
|
|
|
|
EasClient::CreateServiceAutoScalerOutcome EasClient::createServiceAutoScaler(const CreateServiceAutoScalerRequest &request) const
|
|
{
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
if (!endpointOutcome.isSuccess())
|
|
return CreateServiceAutoScalerOutcome(endpointOutcome.error());
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
if (outcome.isSuccess())
|
|
return CreateServiceAutoScalerOutcome(CreateServiceAutoScalerResult(outcome.result()));
|
|
else
|
|
return CreateServiceAutoScalerOutcome(outcome.error());
|
|
}
|
|
|
|
void EasClient::createServiceAutoScalerAsync(const CreateServiceAutoScalerRequest& request, const CreateServiceAutoScalerAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
{
|
|
auto fn = [this, request, handler, context]()
|
|
{
|
|
handler(this, request, createServiceAutoScaler(request), context);
|
|
};
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
}
|
|
|
|
EasClient::CreateServiceAutoScalerOutcomeCallable EasClient::createServiceAutoScalerCallable(const CreateServiceAutoScalerRequest &request) const
|
|
{
|
|
auto task = std::make_shared<std::packaged_task<CreateServiceAutoScalerOutcome()>>(
|
|
[this, request]()
|
|
{
|
|
return this->createServiceAutoScaler(request);
|
|
});
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
return task->get_future();
|
|
}
|
|
|
|
EasClient::CreateServiceCronScalerOutcome EasClient::createServiceCronScaler(const CreateServiceCronScalerRequest &request) const
|
|
{
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
if (!endpointOutcome.isSuccess())
|
|
return CreateServiceCronScalerOutcome(endpointOutcome.error());
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
if (outcome.isSuccess())
|
|
return CreateServiceCronScalerOutcome(CreateServiceCronScalerResult(outcome.result()));
|
|
else
|
|
return CreateServiceCronScalerOutcome(outcome.error());
|
|
}
|
|
|
|
void EasClient::createServiceCronScalerAsync(const CreateServiceCronScalerRequest& request, const CreateServiceCronScalerAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
{
|
|
auto fn = [this, request, handler, context]()
|
|
{
|
|
handler(this, request, createServiceCronScaler(request), context);
|
|
};
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
}
|
|
|
|
EasClient::CreateServiceCronScalerOutcomeCallable EasClient::createServiceCronScalerCallable(const CreateServiceCronScalerRequest &request) const
|
|
{
|
|
auto task = std::make_shared<std::packaged_task<CreateServiceCronScalerOutcome()>>(
|
|
[this, request]()
|
|
{
|
|
return this->createServiceCronScaler(request);
|
|
});
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
return task->get_future();
|
|
}
|
|
|
|
EasClient::CreateServiceMirrorOutcome EasClient::createServiceMirror(const CreateServiceMirrorRequest &request) const
|
|
{
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
if (!endpointOutcome.isSuccess())
|
|
return CreateServiceMirrorOutcome(endpointOutcome.error());
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
if (outcome.isSuccess())
|
|
return CreateServiceMirrorOutcome(CreateServiceMirrorResult(outcome.result()));
|
|
else
|
|
return CreateServiceMirrorOutcome(outcome.error());
|
|
}
|
|
|
|
void EasClient::createServiceMirrorAsync(const CreateServiceMirrorRequest& request, const CreateServiceMirrorAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
{
|
|
auto fn = [this, request, handler, context]()
|
|
{
|
|
handler(this, request, createServiceMirror(request), context);
|
|
};
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
}
|
|
|
|
EasClient::CreateServiceMirrorOutcomeCallable EasClient::createServiceMirrorCallable(const CreateServiceMirrorRequest &request) const
|
|
{
|
|
auto task = std::make_shared<std::packaged_task<CreateServiceMirrorOutcome()>>(
|
|
[this, request]()
|
|
{
|
|
return this->createServiceMirror(request);
|
|
});
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
return task->get_future();
|
|
}
|
|
|
|
EasClient::DeleteBenchmarkTaskOutcome EasClient::deleteBenchmarkTask(const DeleteBenchmarkTaskRequest &request) const
|
|
{
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
if (!endpointOutcome.isSuccess())
|
|
return DeleteBenchmarkTaskOutcome(endpointOutcome.error());
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
if (outcome.isSuccess())
|
|
return DeleteBenchmarkTaskOutcome(DeleteBenchmarkTaskResult(outcome.result()));
|
|
else
|
|
return DeleteBenchmarkTaskOutcome(outcome.error());
|
|
}
|
|
|
|
void EasClient::deleteBenchmarkTaskAsync(const DeleteBenchmarkTaskRequest& request, const DeleteBenchmarkTaskAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
{
|
|
auto fn = [this, request, handler, context]()
|
|
{
|
|
handler(this, request, deleteBenchmarkTask(request), context);
|
|
};
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
}
|
|
|
|
EasClient::DeleteBenchmarkTaskOutcomeCallable EasClient::deleteBenchmarkTaskCallable(const DeleteBenchmarkTaskRequest &request) const
|
|
{
|
|
auto task = std::make_shared<std::packaged_task<DeleteBenchmarkTaskOutcome()>>(
|
|
[this, request]()
|
|
{
|
|
return this->deleteBenchmarkTask(request);
|
|
});
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
return task->get_future();
|
|
}
|
|
|
|
EasClient::DeleteResourceOutcome EasClient::deleteResource(const DeleteResourceRequest &request) const
|
|
{
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
if (!endpointOutcome.isSuccess())
|
|
return DeleteResourceOutcome(endpointOutcome.error());
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
if (outcome.isSuccess())
|
|
return DeleteResourceOutcome(DeleteResourceResult(outcome.result()));
|
|
else
|
|
return DeleteResourceOutcome(outcome.error());
|
|
}
|
|
|
|
void EasClient::deleteResourceAsync(const DeleteResourceRequest& request, const DeleteResourceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
{
|
|
auto fn = [this, request, handler, context]()
|
|
{
|
|
handler(this, request, deleteResource(request), context);
|
|
};
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
}
|
|
|
|
EasClient::DeleteResourceOutcomeCallable EasClient::deleteResourceCallable(const DeleteResourceRequest &request) const
|
|
{
|
|
auto task = std::make_shared<std::packaged_task<DeleteResourceOutcome()>>(
|
|
[this, request]()
|
|
{
|
|
return this->deleteResource(request);
|
|
});
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
return task->get_future();
|
|
}
|
|
|
|
EasClient::DeleteResourceDLinkOutcome EasClient::deleteResourceDLink(const DeleteResourceDLinkRequest &request) const
|
|
{
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
if (!endpointOutcome.isSuccess())
|
|
return DeleteResourceDLinkOutcome(endpointOutcome.error());
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
if (outcome.isSuccess())
|
|
return DeleteResourceDLinkOutcome(DeleteResourceDLinkResult(outcome.result()));
|
|
else
|
|
return DeleteResourceDLinkOutcome(outcome.error());
|
|
}
|
|
|
|
void EasClient::deleteResourceDLinkAsync(const DeleteResourceDLinkRequest& request, const DeleteResourceDLinkAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
{
|
|
auto fn = [this, request, handler, context]()
|
|
{
|
|
handler(this, request, deleteResourceDLink(request), context);
|
|
};
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
}
|
|
|
|
EasClient::DeleteResourceDLinkOutcomeCallable EasClient::deleteResourceDLinkCallable(const DeleteResourceDLinkRequest &request) const
|
|
{
|
|
auto task = std::make_shared<std::packaged_task<DeleteResourceDLinkOutcome()>>(
|
|
[this, request]()
|
|
{
|
|
return this->deleteResourceDLink(request);
|
|
});
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
return task->get_future();
|
|
}
|
|
|
|
EasClient::DeleteResourceInstancesOutcome EasClient::deleteResourceInstances(const DeleteResourceInstancesRequest &request) const
|
|
{
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
if (!endpointOutcome.isSuccess())
|
|
return DeleteResourceInstancesOutcome(endpointOutcome.error());
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
if (outcome.isSuccess())
|
|
return DeleteResourceInstancesOutcome(DeleteResourceInstancesResult(outcome.result()));
|
|
else
|
|
return DeleteResourceInstancesOutcome(outcome.error());
|
|
}
|
|
|
|
void EasClient::deleteResourceInstancesAsync(const DeleteResourceInstancesRequest& request, const DeleteResourceInstancesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
{
|
|
auto fn = [this, request, handler, context]()
|
|
{
|
|
handler(this, request, deleteResourceInstances(request), context);
|
|
};
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
}
|
|
|
|
EasClient::DeleteResourceInstancesOutcomeCallable EasClient::deleteResourceInstancesCallable(const DeleteResourceInstancesRequest &request) const
|
|
{
|
|
auto task = std::make_shared<std::packaged_task<DeleteResourceInstancesOutcome()>>(
|
|
[this, request]()
|
|
{
|
|
return this->deleteResourceInstances(request);
|
|
});
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
return task->get_future();
|
|
}
|
|
|
|
EasClient::DeleteResourceLogOutcome EasClient::deleteResourceLog(const DeleteResourceLogRequest &request) const
|
|
{
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
if (!endpointOutcome.isSuccess())
|
|
return DeleteResourceLogOutcome(endpointOutcome.error());
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
if (outcome.isSuccess())
|
|
return DeleteResourceLogOutcome(DeleteResourceLogResult(outcome.result()));
|
|
else
|
|
return DeleteResourceLogOutcome(outcome.error());
|
|
}
|
|
|
|
void EasClient::deleteResourceLogAsync(const DeleteResourceLogRequest& request, const DeleteResourceLogAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
{
|
|
auto fn = [this, request, handler, context]()
|
|
{
|
|
handler(this, request, deleteResourceLog(request), context);
|
|
};
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
}
|
|
|
|
EasClient::DeleteResourceLogOutcomeCallable EasClient::deleteResourceLogCallable(const DeleteResourceLogRequest &request) const
|
|
{
|
|
auto task = std::make_shared<std::packaged_task<DeleteResourceLogOutcome()>>(
|
|
[this, request]()
|
|
{
|
|
return this->deleteResourceLog(request);
|
|
});
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
return task->get_future();
|
|
}
|
|
|
|
EasClient::DeleteServiceOutcome EasClient::deleteService(const DeleteServiceRequest &request) const
|
|
{
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
if (!endpointOutcome.isSuccess())
|
|
return DeleteServiceOutcome(endpointOutcome.error());
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
if (outcome.isSuccess())
|
|
return DeleteServiceOutcome(DeleteServiceResult(outcome.result()));
|
|
else
|
|
return DeleteServiceOutcome(outcome.error());
|
|
}
|
|
|
|
void EasClient::deleteServiceAsync(const DeleteServiceRequest& request, const DeleteServiceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
{
|
|
auto fn = [this, request, handler, context]()
|
|
{
|
|
handler(this, request, deleteService(request), context);
|
|
};
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
}
|
|
|
|
EasClient::DeleteServiceOutcomeCallable EasClient::deleteServiceCallable(const DeleteServiceRequest &request) const
|
|
{
|
|
auto task = std::make_shared<std::packaged_task<DeleteServiceOutcome()>>(
|
|
[this, request]()
|
|
{
|
|
return this->deleteService(request);
|
|
});
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
return task->get_future();
|
|
}
|
|
|
|
EasClient::DeleteServiceAutoScalerOutcome EasClient::deleteServiceAutoScaler(const DeleteServiceAutoScalerRequest &request) const
|
|
{
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
if (!endpointOutcome.isSuccess())
|
|
return DeleteServiceAutoScalerOutcome(endpointOutcome.error());
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
if (outcome.isSuccess())
|
|
return DeleteServiceAutoScalerOutcome(DeleteServiceAutoScalerResult(outcome.result()));
|
|
else
|
|
return DeleteServiceAutoScalerOutcome(outcome.error());
|
|
}
|
|
|
|
void EasClient::deleteServiceAutoScalerAsync(const DeleteServiceAutoScalerRequest& request, const DeleteServiceAutoScalerAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
{
|
|
auto fn = [this, request, handler, context]()
|
|
{
|
|
handler(this, request, deleteServiceAutoScaler(request), context);
|
|
};
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
}
|
|
|
|
EasClient::DeleteServiceAutoScalerOutcomeCallable EasClient::deleteServiceAutoScalerCallable(const DeleteServiceAutoScalerRequest &request) const
|
|
{
|
|
auto task = std::make_shared<std::packaged_task<DeleteServiceAutoScalerOutcome()>>(
|
|
[this, request]()
|
|
{
|
|
return this->deleteServiceAutoScaler(request);
|
|
});
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
return task->get_future();
|
|
}
|
|
|
|
EasClient::DeleteServiceCronScalerOutcome EasClient::deleteServiceCronScaler(const DeleteServiceCronScalerRequest &request) const
|
|
{
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
if (!endpointOutcome.isSuccess())
|
|
return DeleteServiceCronScalerOutcome(endpointOutcome.error());
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
if (outcome.isSuccess())
|
|
return DeleteServiceCronScalerOutcome(DeleteServiceCronScalerResult(outcome.result()));
|
|
else
|
|
return DeleteServiceCronScalerOutcome(outcome.error());
|
|
}
|
|
|
|
void EasClient::deleteServiceCronScalerAsync(const DeleteServiceCronScalerRequest& request, const DeleteServiceCronScalerAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
{
|
|
auto fn = [this, request, handler, context]()
|
|
{
|
|
handler(this, request, deleteServiceCronScaler(request), context);
|
|
};
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
}
|
|
|
|
EasClient::DeleteServiceCronScalerOutcomeCallable EasClient::deleteServiceCronScalerCallable(const DeleteServiceCronScalerRequest &request) const
|
|
{
|
|
auto task = std::make_shared<std::packaged_task<DeleteServiceCronScalerOutcome()>>(
|
|
[this, request]()
|
|
{
|
|
return this->deleteServiceCronScaler(request);
|
|
});
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
return task->get_future();
|
|
}
|
|
|
|
EasClient::DeleteServiceInstancesOutcome EasClient::deleteServiceInstances(const DeleteServiceInstancesRequest &request) const
|
|
{
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
if (!endpointOutcome.isSuccess())
|
|
return DeleteServiceInstancesOutcome(endpointOutcome.error());
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
if (outcome.isSuccess())
|
|
return DeleteServiceInstancesOutcome(DeleteServiceInstancesResult(outcome.result()));
|
|
else
|
|
return DeleteServiceInstancesOutcome(outcome.error());
|
|
}
|
|
|
|
void EasClient::deleteServiceInstancesAsync(const DeleteServiceInstancesRequest& request, const DeleteServiceInstancesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
{
|
|
auto fn = [this, request, handler, context]()
|
|
{
|
|
handler(this, request, deleteServiceInstances(request), context);
|
|
};
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
}
|
|
|
|
EasClient::DeleteServiceInstancesOutcomeCallable EasClient::deleteServiceInstancesCallable(const DeleteServiceInstancesRequest &request) const
|
|
{
|
|
auto task = std::make_shared<std::packaged_task<DeleteServiceInstancesOutcome()>>(
|
|
[this, request]()
|
|
{
|
|
return this->deleteServiceInstances(request);
|
|
});
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
return task->get_future();
|
|
}
|
|
|
|
EasClient::DeleteServiceLabelOutcome EasClient::deleteServiceLabel(const DeleteServiceLabelRequest &request) const
|
|
{
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
if (!endpointOutcome.isSuccess())
|
|
return DeleteServiceLabelOutcome(endpointOutcome.error());
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
if (outcome.isSuccess())
|
|
return DeleteServiceLabelOutcome(DeleteServiceLabelResult(outcome.result()));
|
|
else
|
|
return DeleteServiceLabelOutcome(outcome.error());
|
|
}
|
|
|
|
void EasClient::deleteServiceLabelAsync(const DeleteServiceLabelRequest& request, const DeleteServiceLabelAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
{
|
|
auto fn = [this, request, handler, context]()
|
|
{
|
|
handler(this, request, deleteServiceLabel(request), context);
|
|
};
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
}
|
|
|
|
EasClient::DeleteServiceLabelOutcomeCallable EasClient::deleteServiceLabelCallable(const DeleteServiceLabelRequest &request) const
|
|
{
|
|
auto task = std::make_shared<std::packaged_task<DeleteServiceLabelOutcome()>>(
|
|
[this, request]()
|
|
{
|
|
return this->deleteServiceLabel(request);
|
|
});
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
return task->get_future();
|
|
}
|
|
|
|
EasClient::DeleteServiceMirrorOutcome EasClient::deleteServiceMirror(const DeleteServiceMirrorRequest &request) const
|
|
{
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
if (!endpointOutcome.isSuccess())
|
|
return DeleteServiceMirrorOutcome(endpointOutcome.error());
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
if (outcome.isSuccess())
|
|
return DeleteServiceMirrorOutcome(DeleteServiceMirrorResult(outcome.result()));
|
|
else
|
|
return DeleteServiceMirrorOutcome(outcome.error());
|
|
}
|
|
|
|
void EasClient::deleteServiceMirrorAsync(const DeleteServiceMirrorRequest& request, const DeleteServiceMirrorAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
{
|
|
auto fn = [this, request, handler, context]()
|
|
{
|
|
handler(this, request, deleteServiceMirror(request), context);
|
|
};
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
}
|
|
|
|
EasClient::DeleteServiceMirrorOutcomeCallable EasClient::deleteServiceMirrorCallable(const DeleteServiceMirrorRequest &request) const
|
|
{
|
|
auto task = std::make_shared<std::packaged_task<DeleteServiceMirrorOutcome()>>(
|
|
[this, request]()
|
|
{
|
|
return this->deleteServiceMirror(request);
|
|
});
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
return task->get_future();
|
|
}
|
|
|
|
EasClient::DescribeBenchmarkTaskOutcome EasClient::describeBenchmarkTask(const DescribeBenchmarkTaskRequest &request) const
|
|
{
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
if (!endpointOutcome.isSuccess())
|
|
return DescribeBenchmarkTaskOutcome(endpointOutcome.error());
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
if (outcome.isSuccess())
|
|
return DescribeBenchmarkTaskOutcome(DescribeBenchmarkTaskResult(outcome.result()));
|
|
else
|
|
return DescribeBenchmarkTaskOutcome(outcome.error());
|
|
}
|
|
|
|
void EasClient::describeBenchmarkTaskAsync(const DescribeBenchmarkTaskRequest& request, const DescribeBenchmarkTaskAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
{
|
|
auto fn = [this, request, handler, context]()
|
|
{
|
|
handler(this, request, describeBenchmarkTask(request), context);
|
|
};
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
}
|
|
|
|
EasClient::DescribeBenchmarkTaskOutcomeCallable EasClient::describeBenchmarkTaskCallable(const DescribeBenchmarkTaskRequest &request) const
|
|
{
|
|
auto task = std::make_shared<std::packaged_task<DescribeBenchmarkTaskOutcome()>>(
|
|
[this, request]()
|
|
{
|
|
return this->describeBenchmarkTask(request);
|
|
});
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
return task->get_future();
|
|
}
|
|
|
|
EasClient::DescribeBenchmarkTaskReportOutcome EasClient::describeBenchmarkTaskReport(const DescribeBenchmarkTaskReportRequest &request) const
|
|
{
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
if (!endpointOutcome.isSuccess())
|
|
return DescribeBenchmarkTaskReportOutcome(endpointOutcome.error());
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
if (outcome.isSuccess())
|
|
return DescribeBenchmarkTaskReportOutcome(DescribeBenchmarkTaskReportResult(outcome.result()));
|
|
else
|
|
return DescribeBenchmarkTaskReportOutcome(outcome.error());
|
|
}
|
|
|
|
void EasClient::describeBenchmarkTaskReportAsync(const DescribeBenchmarkTaskReportRequest& request, const DescribeBenchmarkTaskReportAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
{
|
|
auto fn = [this, request, handler, context]()
|
|
{
|
|
handler(this, request, describeBenchmarkTaskReport(request), context);
|
|
};
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
}
|
|
|
|
EasClient::DescribeBenchmarkTaskReportOutcomeCallable EasClient::describeBenchmarkTaskReportCallable(const DescribeBenchmarkTaskReportRequest &request) const
|
|
{
|
|
auto task = std::make_shared<std::packaged_task<DescribeBenchmarkTaskReportOutcome()>>(
|
|
[this, request]()
|
|
{
|
|
return this->describeBenchmarkTaskReport(request);
|
|
});
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
return task->get_future();
|
|
}
|
|
|
|
EasClient::DescribeGroupOutcome EasClient::describeGroup(const DescribeGroupRequest &request) const
|
|
{
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
if (!endpointOutcome.isSuccess())
|
|
return DescribeGroupOutcome(endpointOutcome.error());
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
if (outcome.isSuccess())
|
|
return DescribeGroupOutcome(DescribeGroupResult(outcome.result()));
|
|
else
|
|
return DescribeGroupOutcome(outcome.error());
|
|
}
|
|
|
|
void EasClient::describeGroupAsync(const DescribeGroupRequest& request, const DescribeGroupAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
{
|
|
auto fn = [this, request, handler, context]()
|
|
{
|
|
handler(this, request, describeGroup(request), context);
|
|
};
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
}
|
|
|
|
EasClient::DescribeGroupOutcomeCallable EasClient::describeGroupCallable(const DescribeGroupRequest &request) const
|
|
{
|
|
auto task = std::make_shared<std::packaged_task<DescribeGroupOutcome()>>(
|
|
[this, request]()
|
|
{
|
|
return this->describeGroup(request);
|
|
});
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
return task->get_future();
|
|
}
|
|
|
|
EasClient::DescribeResourceOutcome EasClient::describeResource(const DescribeResourceRequest &request) const
|
|
{
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
if (!endpointOutcome.isSuccess())
|
|
return DescribeResourceOutcome(endpointOutcome.error());
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
if (outcome.isSuccess())
|
|
return DescribeResourceOutcome(DescribeResourceResult(outcome.result()));
|
|
else
|
|
return DescribeResourceOutcome(outcome.error());
|
|
}
|
|
|
|
void EasClient::describeResourceAsync(const DescribeResourceRequest& request, const DescribeResourceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
{
|
|
auto fn = [this, request, handler, context]()
|
|
{
|
|
handler(this, request, describeResource(request), context);
|
|
};
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
}
|
|
|
|
EasClient::DescribeResourceOutcomeCallable EasClient::describeResourceCallable(const DescribeResourceRequest &request) const
|
|
{
|
|
auto task = std::make_shared<std::packaged_task<DescribeResourceOutcome()>>(
|
|
[this, request]()
|
|
{
|
|
return this->describeResource(request);
|
|
});
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
return task->get_future();
|
|
}
|
|
|
|
EasClient::DescribeResourceDLinkOutcome EasClient::describeResourceDLink(const DescribeResourceDLinkRequest &request) const
|
|
{
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
if (!endpointOutcome.isSuccess())
|
|
return DescribeResourceDLinkOutcome(endpointOutcome.error());
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
if (outcome.isSuccess())
|
|
return DescribeResourceDLinkOutcome(DescribeResourceDLinkResult(outcome.result()));
|
|
else
|
|
return DescribeResourceDLinkOutcome(outcome.error());
|
|
}
|
|
|
|
void EasClient::describeResourceDLinkAsync(const DescribeResourceDLinkRequest& request, const DescribeResourceDLinkAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
{
|
|
auto fn = [this, request, handler, context]()
|
|
{
|
|
handler(this, request, describeResourceDLink(request), context);
|
|
};
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
}
|
|
|
|
EasClient::DescribeResourceDLinkOutcomeCallable EasClient::describeResourceDLinkCallable(const DescribeResourceDLinkRequest &request) const
|
|
{
|
|
auto task = std::make_shared<std::packaged_task<DescribeResourceDLinkOutcome()>>(
|
|
[this, request]()
|
|
{
|
|
return this->describeResourceDLink(request);
|
|
});
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
return task->get_future();
|
|
}
|
|
|
|
EasClient::DescribeResourceLogOutcome EasClient::describeResourceLog(const DescribeResourceLogRequest &request) const
|
|
{
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
if (!endpointOutcome.isSuccess())
|
|
return DescribeResourceLogOutcome(endpointOutcome.error());
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
if (outcome.isSuccess())
|
|
return DescribeResourceLogOutcome(DescribeResourceLogResult(outcome.result()));
|
|
else
|
|
return DescribeResourceLogOutcome(outcome.error());
|
|
}
|
|
|
|
void EasClient::describeResourceLogAsync(const DescribeResourceLogRequest& request, const DescribeResourceLogAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
{
|
|
auto fn = [this, request, handler, context]()
|
|
{
|
|
handler(this, request, describeResourceLog(request), context);
|
|
};
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
}
|
|
|
|
EasClient::DescribeResourceLogOutcomeCallable EasClient::describeResourceLogCallable(const DescribeResourceLogRequest &request) const
|
|
{
|
|
auto task = std::make_shared<std::packaged_task<DescribeResourceLogOutcome()>>(
|
|
[this, request]()
|
|
{
|
|
return this->describeResourceLog(request);
|
|
});
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
return task->get_future();
|
|
}
|
|
|
|
EasClient::DescribeServiceOutcome EasClient::describeService(const DescribeServiceRequest &request) const
|
|
{
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
if (!endpointOutcome.isSuccess())
|
|
return DescribeServiceOutcome(endpointOutcome.error());
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
if (outcome.isSuccess())
|
|
return DescribeServiceOutcome(DescribeServiceResult(outcome.result()));
|
|
else
|
|
return DescribeServiceOutcome(outcome.error());
|
|
}
|
|
|
|
void EasClient::describeServiceAsync(const DescribeServiceRequest& request, const DescribeServiceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
{
|
|
auto fn = [this, request, handler, context]()
|
|
{
|
|
handler(this, request, describeService(request), context);
|
|
};
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
}
|
|
|
|
EasClient::DescribeServiceOutcomeCallable EasClient::describeServiceCallable(const DescribeServiceRequest &request) const
|
|
{
|
|
auto task = std::make_shared<std::packaged_task<DescribeServiceOutcome()>>(
|
|
[this, request]()
|
|
{
|
|
return this->describeService(request);
|
|
});
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
return task->get_future();
|
|
}
|
|
|
|
EasClient::DescribeServiceAutoScalerOutcome EasClient::describeServiceAutoScaler(const DescribeServiceAutoScalerRequest &request) const
|
|
{
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
if (!endpointOutcome.isSuccess())
|
|
return DescribeServiceAutoScalerOutcome(endpointOutcome.error());
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
if (outcome.isSuccess())
|
|
return DescribeServiceAutoScalerOutcome(DescribeServiceAutoScalerResult(outcome.result()));
|
|
else
|
|
return DescribeServiceAutoScalerOutcome(outcome.error());
|
|
}
|
|
|
|
void EasClient::describeServiceAutoScalerAsync(const DescribeServiceAutoScalerRequest& request, const DescribeServiceAutoScalerAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
{
|
|
auto fn = [this, request, handler, context]()
|
|
{
|
|
handler(this, request, describeServiceAutoScaler(request), context);
|
|
};
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
}
|
|
|
|
EasClient::DescribeServiceAutoScalerOutcomeCallable EasClient::describeServiceAutoScalerCallable(const DescribeServiceAutoScalerRequest &request) const
|
|
{
|
|
auto task = std::make_shared<std::packaged_task<DescribeServiceAutoScalerOutcome()>>(
|
|
[this, request]()
|
|
{
|
|
return this->describeServiceAutoScaler(request);
|
|
});
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
return task->get_future();
|
|
}
|
|
|
|
EasClient::DescribeServiceCronScalerOutcome EasClient::describeServiceCronScaler(const DescribeServiceCronScalerRequest &request) const
|
|
{
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
if (!endpointOutcome.isSuccess())
|
|
return DescribeServiceCronScalerOutcome(endpointOutcome.error());
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
if (outcome.isSuccess())
|
|
return DescribeServiceCronScalerOutcome(DescribeServiceCronScalerResult(outcome.result()));
|
|
else
|
|
return DescribeServiceCronScalerOutcome(outcome.error());
|
|
}
|
|
|
|
void EasClient::describeServiceCronScalerAsync(const DescribeServiceCronScalerRequest& request, const DescribeServiceCronScalerAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
{
|
|
auto fn = [this, request, handler, context]()
|
|
{
|
|
handler(this, request, describeServiceCronScaler(request), context);
|
|
};
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
}
|
|
|
|
EasClient::DescribeServiceCronScalerOutcomeCallable EasClient::describeServiceCronScalerCallable(const DescribeServiceCronScalerRequest &request) const
|
|
{
|
|
auto task = std::make_shared<std::packaged_task<DescribeServiceCronScalerOutcome()>>(
|
|
[this, request]()
|
|
{
|
|
return this->describeServiceCronScaler(request);
|
|
});
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
return task->get_future();
|
|
}
|
|
|
|
EasClient::DescribeServiceEventOutcome EasClient::describeServiceEvent(const DescribeServiceEventRequest &request) const
|
|
{
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
if (!endpointOutcome.isSuccess())
|
|
return DescribeServiceEventOutcome(endpointOutcome.error());
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
if (outcome.isSuccess())
|
|
return DescribeServiceEventOutcome(DescribeServiceEventResult(outcome.result()));
|
|
else
|
|
return DescribeServiceEventOutcome(outcome.error());
|
|
}
|
|
|
|
void EasClient::describeServiceEventAsync(const DescribeServiceEventRequest& request, const DescribeServiceEventAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
{
|
|
auto fn = [this, request, handler, context]()
|
|
{
|
|
handler(this, request, describeServiceEvent(request), context);
|
|
};
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
}
|
|
|
|
EasClient::DescribeServiceEventOutcomeCallable EasClient::describeServiceEventCallable(const DescribeServiceEventRequest &request) const
|
|
{
|
|
auto task = std::make_shared<std::packaged_task<DescribeServiceEventOutcome()>>(
|
|
[this, request]()
|
|
{
|
|
return this->describeServiceEvent(request);
|
|
});
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
return task->get_future();
|
|
}
|
|
|
|
EasClient::DescribeServiceLogOutcome EasClient::describeServiceLog(const DescribeServiceLogRequest &request) const
|
|
{
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
if (!endpointOutcome.isSuccess())
|
|
return DescribeServiceLogOutcome(endpointOutcome.error());
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
if (outcome.isSuccess())
|
|
return DescribeServiceLogOutcome(DescribeServiceLogResult(outcome.result()));
|
|
else
|
|
return DescribeServiceLogOutcome(outcome.error());
|
|
}
|
|
|
|
void EasClient::describeServiceLogAsync(const DescribeServiceLogRequest& request, const DescribeServiceLogAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
{
|
|
auto fn = [this, request, handler, context]()
|
|
{
|
|
handler(this, request, describeServiceLog(request), context);
|
|
};
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
}
|
|
|
|
EasClient::DescribeServiceLogOutcomeCallable EasClient::describeServiceLogCallable(const DescribeServiceLogRequest &request) const
|
|
{
|
|
auto task = std::make_shared<std::packaged_task<DescribeServiceLogOutcome()>>(
|
|
[this, request]()
|
|
{
|
|
return this->describeServiceLog(request);
|
|
});
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
return task->get_future();
|
|
}
|
|
|
|
EasClient::DescribeServiceMirrorOutcome EasClient::describeServiceMirror(const DescribeServiceMirrorRequest &request) const
|
|
{
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
if (!endpointOutcome.isSuccess())
|
|
return DescribeServiceMirrorOutcome(endpointOutcome.error());
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
if (outcome.isSuccess())
|
|
return DescribeServiceMirrorOutcome(DescribeServiceMirrorResult(outcome.result()));
|
|
else
|
|
return DescribeServiceMirrorOutcome(outcome.error());
|
|
}
|
|
|
|
void EasClient::describeServiceMirrorAsync(const DescribeServiceMirrorRequest& request, const DescribeServiceMirrorAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
{
|
|
auto fn = [this, request, handler, context]()
|
|
{
|
|
handler(this, request, describeServiceMirror(request), context);
|
|
};
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
}
|
|
|
|
EasClient::DescribeServiceMirrorOutcomeCallable EasClient::describeServiceMirrorCallable(const DescribeServiceMirrorRequest &request) const
|
|
{
|
|
auto task = std::make_shared<std::packaged_task<DescribeServiceMirrorOutcome()>>(
|
|
[this, request]()
|
|
{
|
|
return this->describeServiceMirror(request);
|
|
});
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
return task->get_future();
|
|
}
|
|
|
|
EasClient::DevelopServiceOutcome EasClient::developService(const DevelopServiceRequest &request) const
|
|
{
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
if (!endpointOutcome.isSuccess())
|
|
return DevelopServiceOutcome(endpointOutcome.error());
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
if (outcome.isSuccess())
|
|
return DevelopServiceOutcome(DevelopServiceResult(outcome.result()));
|
|
else
|
|
return DevelopServiceOutcome(outcome.error());
|
|
}
|
|
|
|
void EasClient::developServiceAsync(const DevelopServiceRequest& request, const DevelopServiceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
{
|
|
auto fn = [this, request, handler, context]()
|
|
{
|
|
handler(this, request, developService(request), context);
|
|
};
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
}
|
|
|
|
EasClient::DevelopServiceOutcomeCallable EasClient::developServiceCallable(const DevelopServiceRequest &request) const
|
|
{
|
|
auto task = std::make_shared<std::packaged_task<DevelopServiceOutcome()>>(
|
|
[this, request]()
|
|
{
|
|
return this->developService(request);
|
|
});
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
return task->get_future();
|
|
}
|
|
|
|
EasClient::ListBenchmarkTaskOutcome EasClient::listBenchmarkTask(const ListBenchmarkTaskRequest &request) const
|
|
{
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
if (!endpointOutcome.isSuccess())
|
|
return ListBenchmarkTaskOutcome(endpointOutcome.error());
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
if (outcome.isSuccess())
|
|
return ListBenchmarkTaskOutcome(ListBenchmarkTaskResult(outcome.result()));
|
|
else
|
|
return ListBenchmarkTaskOutcome(outcome.error());
|
|
}
|
|
|
|
void EasClient::listBenchmarkTaskAsync(const ListBenchmarkTaskRequest& request, const ListBenchmarkTaskAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
{
|
|
auto fn = [this, request, handler, context]()
|
|
{
|
|
handler(this, request, listBenchmarkTask(request), context);
|
|
};
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
}
|
|
|
|
EasClient::ListBenchmarkTaskOutcomeCallable EasClient::listBenchmarkTaskCallable(const ListBenchmarkTaskRequest &request) const
|
|
{
|
|
auto task = std::make_shared<std::packaged_task<ListBenchmarkTaskOutcome()>>(
|
|
[this, request]()
|
|
{
|
|
return this->listBenchmarkTask(request);
|
|
});
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
return task->get_future();
|
|
}
|
|
|
|
EasClient::ListGroupsOutcome EasClient::listGroups(const ListGroupsRequest &request) const
|
|
{
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
if (!endpointOutcome.isSuccess())
|
|
return ListGroupsOutcome(endpointOutcome.error());
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
if (outcome.isSuccess())
|
|
return ListGroupsOutcome(ListGroupsResult(outcome.result()));
|
|
else
|
|
return ListGroupsOutcome(outcome.error());
|
|
}
|
|
|
|
void EasClient::listGroupsAsync(const ListGroupsRequest& request, const ListGroupsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
{
|
|
auto fn = [this, request, handler, context]()
|
|
{
|
|
handler(this, request, listGroups(request), context);
|
|
};
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
}
|
|
|
|
EasClient::ListGroupsOutcomeCallable EasClient::listGroupsCallable(const ListGroupsRequest &request) const
|
|
{
|
|
auto task = std::make_shared<std::packaged_task<ListGroupsOutcome()>>(
|
|
[this, request]()
|
|
{
|
|
return this->listGroups(request);
|
|
});
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
return task->get_future();
|
|
}
|
|
|
|
EasClient::ListResourceInstanceWorkerOutcome EasClient::listResourceInstanceWorker(const ListResourceInstanceWorkerRequest &request) const
|
|
{
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
if (!endpointOutcome.isSuccess())
|
|
return ListResourceInstanceWorkerOutcome(endpointOutcome.error());
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
if (outcome.isSuccess())
|
|
return ListResourceInstanceWorkerOutcome(ListResourceInstanceWorkerResult(outcome.result()));
|
|
else
|
|
return ListResourceInstanceWorkerOutcome(outcome.error());
|
|
}
|
|
|
|
void EasClient::listResourceInstanceWorkerAsync(const ListResourceInstanceWorkerRequest& request, const ListResourceInstanceWorkerAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
{
|
|
auto fn = [this, request, handler, context]()
|
|
{
|
|
handler(this, request, listResourceInstanceWorker(request), context);
|
|
};
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
}
|
|
|
|
EasClient::ListResourceInstanceWorkerOutcomeCallable EasClient::listResourceInstanceWorkerCallable(const ListResourceInstanceWorkerRequest &request) const
|
|
{
|
|
auto task = std::make_shared<std::packaged_task<ListResourceInstanceWorkerOutcome()>>(
|
|
[this, request]()
|
|
{
|
|
return this->listResourceInstanceWorker(request);
|
|
});
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
return task->get_future();
|
|
}
|
|
|
|
EasClient::ListResourceInstancesOutcome EasClient::listResourceInstances(const ListResourceInstancesRequest &request) const
|
|
{
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
if (!endpointOutcome.isSuccess())
|
|
return ListResourceInstancesOutcome(endpointOutcome.error());
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
if (outcome.isSuccess())
|
|
return ListResourceInstancesOutcome(ListResourceInstancesResult(outcome.result()));
|
|
else
|
|
return ListResourceInstancesOutcome(outcome.error());
|
|
}
|
|
|
|
void EasClient::listResourceInstancesAsync(const ListResourceInstancesRequest& request, const ListResourceInstancesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
{
|
|
auto fn = [this, request, handler, context]()
|
|
{
|
|
handler(this, request, listResourceInstances(request), context);
|
|
};
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
}
|
|
|
|
EasClient::ListResourceInstancesOutcomeCallable EasClient::listResourceInstancesCallable(const ListResourceInstancesRequest &request) const
|
|
{
|
|
auto task = std::make_shared<std::packaged_task<ListResourceInstancesOutcome()>>(
|
|
[this, request]()
|
|
{
|
|
return this->listResourceInstances(request);
|
|
});
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
return task->get_future();
|
|
}
|
|
|
|
EasClient::ListResourceServicesOutcome EasClient::listResourceServices(const ListResourceServicesRequest &request) const
|
|
{
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
if (!endpointOutcome.isSuccess())
|
|
return ListResourceServicesOutcome(endpointOutcome.error());
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
if (outcome.isSuccess())
|
|
return ListResourceServicesOutcome(ListResourceServicesResult(outcome.result()));
|
|
else
|
|
return ListResourceServicesOutcome(outcome.error());
|
|
}
|
|
|
|
void EasClient::listResourceServicesAsync(const ListResourceServicesRequest& request, const ListResourceServicesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
{
|
|
auto fn = [this, request, handler, context]()
|
|
{
|
|
handler(this, request, listResourceServices(request), context);
|
|
};
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
}
|
|
|
|
EasClient::ListResourceServicesOutcomeCallable EasClient::listResourceServicesCallable(const ListResourceServicesRequest &request) const
|
|
{
|
|
auto task = std::make_shared<std::packaged_task<ListResourceServicesOutcome()>>(
|
|
[this, request]()
|
|
{
|
|
return this->listResourceServices(request);
|
|
});
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
return task->get_future();
|
|
}
|
|
|
|
EasClient::ListResourcesOutcome EasClient::listResources(const ListResourcesRequest &request) const
|
|
{
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
if (!endpointOutcome.isSuccess())
|
|
return ListResourcesOutcome(endpointOutcome.error());
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
if (outcome.isSuccess())
|
|
return ListResourcesOutcome(ListResourcesResult(outcome.result()));
|
|
else
|
|
return ListResourcesOutcome(outcome.error());
|
|
}
|
|
|
|
void EasClient::listResourcesAsync(const ListResourcesRequest& request, const ListResourcesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
{
|
|
auto fn = [this, request, handler, context]()
|
|
{
|
|
handler(this, request, listResources(request), context);
|
|
};
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
}
|
|
|
|
EasClient::ListResourcesOutcomeCallable EasClient::listResourcesCallable(const ListResourcesRequest &request) const
|
|
{
|
|
auto task = std::make_shared<std::packaged_task<ListResourcesOutcome()>>(
|
|
[this, request]()
|
|
{
|
|
return this->listResources(request);
|
|
});
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
return task->get_future();
|
|
}
|
|
|
|
EasClient::ListServiceInstancesOutcome EasClient::listServiceInstances(const ListServiceInstancesRequest &request) const
|
|
{
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
if (!endpointOutcome.isSuccess())
|
|
return ListServiceInstancesOutcome(endpointOutcome.error());
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
if (outcome.isSuccess())
|
|
return ListServiceInstancesOutcome(ListServiceInstancesResult(outcome.result()));
|
|
else
|
|
return ListServiceInstancesOutcome(outcome.error());
|
|
}
|
|
|
|
void EasClient::listServiceInstancesAsync(const ListServiceInstancesRequest& request, const ListServiceInstancesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
{
|
|
auto fn = [this, request, handler, context]()
|
|
{
|
|
handler(this, request, listServiceInstances(request), context);
|
|
};
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
}
|
|
|
|
EasClient::ListServiceInstancesOutcomeCallable EasClient::listServiceInstancesCallable(const ListServiceInstancesRequest &request) const
|
|
{
|
|
auto task = std::make_shared<std::packaged_task<ListServiceInstancesOutcome()>>(
|
|
[this, request]()
|
|
{
|
|
return this->listServiceInstances(request);
|
|
});
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
return task->get_future();
|
|
}
|
|
|
|
EasClient::ListServiceVersionsOutcome EasClient::listServiceVersions(const ListServiceVersionsRequest &request) const
|
|
{
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
if (!endpointOutcome.isSuccess())
|
|
return ListServiceVersionsOutcome(endpointOutcome.error());
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
if (outcome.isSuccess())
|
|
return ListServiceVersionsOutcome(ListServiceVersionsResult(outcome.result()));
|
|
else
|
|
return ListServiceVersionsOutcome(outcome.error());
|
|
}
|
|
|
|
void EasClient::listServiceVersionsAsync(const ListServiceVersionsRequest& request, const ListServiceVersionsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
{
|
|
auto fn = [this, request, handler, context]()
|
|
{
|
|
handler(this, request, listServiceVersions(request), context);
|
|
};
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
}
|
|
|
|
EasClient::ListServiceVersionsOutcomeCallable EasClient::listServiceVersionsCallable(const ListServiceVersionsRequest &request) const
|
|
{
|
|
auto task = std::make_shared<std::packaged_task<ListServiceVersionsOutcome()>>(
|
|
[this, request]()
|
|
{
|
|
return this->listServiceVersions(request);
|
|
});
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
return task->get_future();
|
|
}
|
|
|
|
EasClient::ListServicesOutcome EasClient::listServices(const ListServicesRequest &request) const
|
|
{
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
if (!endpointOutcome.isSuccess())
|
|
return ListServicesOutcome(endpointOutcome.error());
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
if (outcome.isSuccess())
|
|
return ListServicesOutcome(ListServicesResult(outcome.result()));
|
|
else
|
|
return ListServicesOutcome(outcome.error());
|
|
}
|
|
|
|
void EasClient::listServicesAsync(const ListServicesRequest& request, const ListServicesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
{
|
|
auto fn = [this, request, handler, context]()
|
|
{
|
|
handler(this, request, listServices(request), context);
|
|
};
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
}
|
|
|
|
EasClient::ListServicesOutcomeCallable EasClient::listServicesCallable(const ListServicesRequest &request) const
|
|
{
|
|
auto task = std::make_shared<std::packaged_task<ListServicesOutcome()>>(
|
|
[this, request]()
|
|
{
|
|
return this->listServices(request);
|
|
});
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
return task->get_future();
|
|
}
|
|
|
|
EasClient::ReleaseServiceOutcome EasClient::releaseService(const ReleaseServiceRequest &request) const
|
|
{
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
if (!endpointOutcome.isSuccess())
|
|
return ReleaseServiceOutcome(endpointOutcome.error());
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
if (outcome.isSuccess())
|
|
return ReleaseServiceOutcome(ReleaseServiceResult(outcome.result()));
|
|
else
|
|
return ReleaseServiceOutcome(outcome.error());
|
|
}
|
|
|
|
void EasClient::releaseServiceAsync(const ReleaseServiceRequest& request, const ReleaseServiceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
{
|
|
auto fn = [this, request, handler, context]()
|
|
{
|
|
handler(this, request, releaseService(request), context);
|
|
};
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
}
|
|
|
|
EasClient::ReleaseServiceOutcomeCallable EasClient::releaseServiceCallable(const ReleaseServiceRequest &request) const
|
|
{
|
|
auto task = std::make_shared<std::packaged_task<ReleaseServiceOutcome()>>(
|
|
[this, request]()
|
|
{
|
|
return this->releaseService(request);
|
|
});
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
return task->get_future();
|
|
}
|
|
|
|
EasClient::StartBenchmarkTaskOutcome EasClient::startBenchmarkTask(const StartBenchmarkTaskRequest &request) const
|
|
{
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
if (!endpointOutcome.isSuccess())
|
|
return StartBenchmarkTaskOutcome(endpointOutcome.error());
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
if (outcome.isSuccess())
|
|
return StartBenchmarkTaskOutcome(StartBenchmarkTaskResult(outcome.result()));
|
|
else
|
|
return StartBenchmarkTaskOutcome(outcome.error());
|
|
}
|
|
|
|
void EasClient::startBenchmarkTaskAsync(const StartBenchmarkTaskRequest& request, const StartBenchmarkTaskAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
{
|
|
auto fn = [this, request, handler, context]()
|
|
{
|
|
handler(this, request, startBenchmarkTask(request), context);
|
|
};
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
}
|
|
|
|
EasClient::StartBenchmarkTaskOutcomeCallable EasClient::startBenchmarkTaskCallable(const StartBenchmarkTaskRequest &request) const
|
|
{
|
|
auto task = std::make_shared<std::packaged_task<StartBenchmarkTaskOutcome()>>(
|
|
[this, request]()
|
|
{
|
|
return this->startBenchmarkTask(request);
|
|
});
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
return task->get_future();
|
|
}
|
|
|
|
EasClient::StartServiceOutcome EasClient::startService(const StartServiceRequest &request) const
|
|
{
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
if (!endpointOutcome.isSuccess())
|
|
return StartServiceOutcome(endpointOutcome.error());
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
if (outcome.isSuccess())
|
|
return StartServiceOutcome(StartServiceResult(outcome.result()));
|
|
else
|
|
return StartServiceOutcome(outcome.error());
|
|
}
|
|
|
|
void EasClient::startServiceAsync(const StartServiceRequest& request, const StartServiceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
{
|
|
auto fn = [this, request, handler, context]()
|
|
{
|
|
handler(this, request, startService(request), context);
|
|
};
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
}
|
|
|
|
EasClient::StartServiceOutcomeCallable EasClient::startServiceCallable(const StartServiceRequest &request) const
|
|
{
|
|
auto task = std::make_shared<std::packaged_task<StartServiceOutcome()>>(
|
|
[this, request]()
|
|
{
|
|
return this->startService(request);
|
|
});
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
return task->get_future();
|
|
}
|
|
|
|
EasClient::StopBenchmarkTaskOutcome EasClient::stopBenchmarkTask(const StopBenchmarkTaskRequest &request) const
|
|
{
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
if (!endpointOutcome.isSuccess())
|
|
return StopBenchmarkTaskOutcome(endpointOutcome.error());
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
if (outcome.isSuccess())
|
|
return StopBenchmarkTaskOutcome(StopBenchmarkTaskResult(outcome.result()));
|
|
else
|
|
return StopBenchmarkTaskOutcome(outcome.error());
|
|
}
|
|
|
|
void EasClient::stopBenchmarkTaskAsync(const StopBenchmarkTaskRequest& request, const StopBenchmarkTaskAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
{
|
|
auto fn = [this, request, handler, context]()
|
|
{
|
|
handler(this, request, stopBenchmarkTask(request), context);
|
|
};
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
}
|
|
|
|
EasClient::StopBenchmarkTaskOutcomeCallable EasClient::stopBenchmarkTaskCallable(const StopBenchmarkTaskRequest &request) const
|
|
{
|
|
auto task = std::make_shared<std::packaged_task<StopBenchmarkTaskOutcome()>>(
|
|
[this, request]()
|
|
{
|
|
return this->stopBenchmarkTask(request);
|
|
});
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
return task->get_future();
|
|
}
|
|
|
|
EasClient::StopServiceOutcome EasClient::stopService(const StopServiceRequest &request) const
|
|
{
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
if (!endpointOutcome.isSuccess())
|
|
return StopServiceOutcome(endpointOutcome.error());
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
if (outcome.isSuccess())
|
|
return StopServiceOutcome(StopServiceResult(outcome.result()));
|
|
else
|
|
return StopServiceOutcome(outcome.error());
|
|
}
|
|
|
|
void EasClient::stopServiceAsync(const StopServiceRequest& request, const StopServiceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
{
|
|
auto fn = [this, request, handler, context]()
|
|
{
|
|
handler(this, request, stopService(request), context);
|
|
};
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
}
|
|
|
|
EasClient::StopServiceOutcomeCallable EasClient::stopServiceCallable(const StopServiceRequest &request) const
|
|
{
|
|
auto task = std::make_shared<std::packaged_task<StopServiceOutcome()>>(
|
|
[this, request]()
|
|
{
|
|
return this->stopService(request);
|
|
});
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
return task->get_future();
|
|
}
|
|
|
|
EasClient::UpdateBenchmarkTaskOutcome EasClient::updateBenchmarkTask(const UpdateBenchmarkTaskRequest &request) const
|
|
{
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
if (!endpointOutcome.isSuccess())
|
|
return UpdateBenchmarkTaskOutcome(endpointOutcome.error());
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
if (outcome.isSuccess())
|
|
return UpdateBenchmarkTaskOutcome(UpdateBenchmarkTaskResult(outcome.result()));
|
|
else
|
|
return UpdateBenchmarkTaskOutcome(outcome.error());
|
|
}
|
|
|
|
void EasClient::updateBenchmarkTaskAsync(const UpdateBenchmarkTaskRequest& request, const UpdateBenchmarkTaskAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
{
|
|
auto fn = [this, request, handler, context]()
|
|
{
|
|
handler(this, request, updateBenchmarkTask(request), context);
|
|
};
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
}
|
|
|
|
EasClient::UpdateBenchmarkTaskOutcomeCallable EasClient::updateBenchmarkTaskCallable(const UpdateBenchmarkTaskRequest &request) const
|
|
{
|
|
auto task = std::make_shared<std::packaged_task<UpdateBenchmarkTaskOutcome()>>(
|
|
[this, request]()
|
|
{
|
|
return this->updateBenchmarkTask(request);
|
|
});
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
return task->get_future();
|
|
}
|
|
|
|
EasClient::UpdateResourceOutcome EasClient::updateResource(const UpdateResourceRequest &request) const
|
|
{
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
if (!endpointOutcome.isSuccess())
|
|
return UpdateResourceOutcome(endpointOutcome.error());
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
if (outcome.isSuccess())
|
|
return UpdateResourceOutcome(UpdateResourceResult(outcome.result()));
|
|
else
|
|
return UpdateResourceOutcome(outcome.error());
|
|
}
|
|
|
|
void EasClient::updateResourceAsync(const UpdateResourceRequest& request, const UpdateResourceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
{
|
|
auto fn = [this, request, handler, context]()
|
|
{
|
|
handler(this, request, updateResource(request), context);
|
|
};
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
}
|
|
|
|
EasClient::UpdateResourceOutcomeCallable EasClient::updateResourceCallable(const UpdateResourceRequest &request) const
|
|
{
|
|
auto task = std::make_shared<std::packaged_task<UpdateResourceOutcome()>>(
|
|
[this, request]()
|
|
{
|
|
return this->updateResource(request);
|
|
});
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
return task->get_future();
|
|
}
|
|
|
|
EasClient::UpdateResourceDLinkOutcome EasClient::updateResourceDLink(const UpdateResourceDLinkRequest &request) const
|
|
{
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
if (!endpointOutcome.isSuccess())
|
|
return UpdateResourceDLinkOutcome(endpointOutcome.error());
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
if (outcome.isSuccess())
|
|
return UpdateResourceDLinkOutcome(UpdateResourceDLinkResult(outcome.result()));
|
|
else
|
|
return UpdateResourceDLinkOutcome(outcome.error());
|
|
}
|
|
|
|
void EasClient::updateResourceDLinkAsync(const UpdateResourceDLinkRequest& request, const UpdateResourceDLinkAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
{
|
|
auto fn = [this, request, handler, context]()
|
|
{
|
|
handler(this, request, updateResourceDLink(request), context);
|
|
};
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
}
|
|
|
|
EasClient::UpdateResourceDLinkOutcomeCallable EasClient::updateResourceDLinkCallable(const UpdateResourceDLinkRequest &request) const
|
|
{
|
|
auto task = std::make_shared<std::packaged_task<UpdateResourceDLinkOutcome()>>(
|
|
[this, request]()
|
|
{
|
|
return this->updateResourceDLink(request);
|
|
});
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
return task->get_future();
|
|
}
|
|
|
|
EasClient::UpdateResourceInstanceOutcome EasClient::updateResourceInstance(const UpdateResourceInstanceRequest &request) const
|
|
{
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
if (!endpointOutcome.isSuccess())
|
|
return UpdateResourceInstanceOutcome(endpointOutcome.error());
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
if (outcome.isSuccess())
|
|
return UpdateResourceInstanceOutcome(UpdateResourceInstanceResult(outcome.result()));
|
|
else
|
|
return UpdateResourceInstanceOutcome(outcome.error());
|
|
}
|
|
|
|
void EasClient::updateResourceInstanceAsync(const UpdateResourceInstanceRequest& request, const UpdateResourceInstanceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
{
|
|
auto fn = [this, request, handler, context]()
|
|
{
|
|
handler(this, request, updateResourceInstance(request), context);
|
|
};
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
}
|
|
|
|
EasClient::UpdateResourceInstanceOutcomeCallable EasClient::updateResourceInstanceCallable(const UpdateResourceInstanceRequest &request) const
|
|
{
|
|
auto task = std::make_shared<std::packaged_task<UpdateResourceInstanceOutcome()>>(
|
|
[this, request]()
|
|
{
|
|
return this->updateResourceInstance(request);
|
|
});
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
return task->get_future();
|
|
}
|
|
|
|
EasClient::UpdateServiceOutcome EasClient::updateService(const UpdateServiceRequest &request) const
|
|
{
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
if (!endpointOutcome.isSuccess())
|
|
return UpdateServiceOutcome(endpointOutcome.error());
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
if (outcome.isSuccess())
|
|
return UpdateServiceOutcome(UpdateServiceResult(outcome.result()));
|
|
else
|
|
return UpdateServiceOutcome(outcome.error());
|
|
}
|
|
|
|
void EasClient::updateServiceAsync(const UpdateServiceRequest& request, const UpdateServiceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
{
|
|
auto fn = [this, request, handler, context]()
|
|
{
|
|
handler(this, request, updateService(request), context);
|
|
};
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
}
|
|
|
|
EasClient::UpdateServiceOutcomeCallable EasClient::updateServiceCallable(const UpdateServiceRequest &request) const
|
|
{
|
|
auto task = std::make_shared<std::packaged_task<UpdateServiceOutcome()>>(
|
|
[this, request]()
|
|
{
|
|
return this->updateService(request);
|
|
});
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
return task->get_future();
|
|
}
|
|
|
|
EasClient::UpdateServiceAutoScalerOutcome EasClient::updateServiceAutoScaler(const UpdateServiceAutoScalerRequest &request) const
|
|
{
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
if (!endpointOutcome.isSuccess())
|
|
return UpdateServiceAutoScalerOutcome(endpointOutcome.error());
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
if (outcome.isSuccess())
|
|
return UpdateServiceAutoScalerOutcome(UpdateServiceAutoScalerResult(outcome.result()));
|
|
else
|
|
return UpdateServiceAutoScalerOutcome(outcome.error());
|
|
}
|
|
|
|
void EasClient::updateServiceAutoScalerAsync(const UpdateServiceAutoScalerRequest& request, const UpdateServiceAutoScalerAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
{
|
|
auto fn = [this, request, handler, context]()
|
|
{
|
|
handler(this, request, updateServiceAutoScaler(request), context);
|
|
};
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
}
|
|
|
|
EasClient::UpdateServiceAutoScalerOutcomeCallable EasClient::updateServiceAutoScalerCallable(const UpdateServiceAutoScalerRequest &request) const
|
|
{
|
|
auto task = std::make_shared<std::packaged_task<UpdateServiceAutoScalerOutcome()>>(
|
|
[this, request]()
|
|
{
|
|
return this->updateServiceAutoScaler(request);
|
|
});
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
return task->get_future();
|
|
}
|
|
|
|
EasClient::UpdateServiceCronScalerOutcome EasClient::updateServiceCronScaler(const UpdateServiceCronScalerRequest &request) const
|
|
{
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
if (!endpointOutcome.isSuccess())
|
|
return UpdateServiceCronScalerOutcome(endpointOutcome.error());
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
if (outcome.isSuccess())
|
|
return UpdateServiceCronScalerOutcome(UpdateServiceCronScalerResult(outcome.result()));
|
|
else
|
|
return UpdateServiceCronScalerOutcome(outcome.error());
|
|
}
|
|
|
|
void EasClient::updateServiceCronScalerAsync(const UpdateServiceCronScalerRequest& request, const UpdateServiceCronScalerAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
{
|
|
auto fn = [this, request, handler, context]()
|
|
{
|
|
handler(this, request, updateServiceCronScaler(request), context);
|
|
};
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
}
|
|
|
|
EasClient::UpdateServiceCronScalerOutcomeCallable EasClient::updateServiceCronScalerCallable(const UpdateServiceCronScalerRequest &request) const
|
|
{
|
|
auto task = std::make_shared<std::packaged_task<UpdateServiceCronScalerOutcome()>>(
|
|
[this, request]()
|
|
{
|
|
return this->updateServiceCronScaler(request);
|
|
});
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
return task->get_future();
|
|
}
|
|
|
|
EasClient::UpdateServiceLabelOutcome EasClient::updateServiceLabel(const UpdateServiceLabelRequest &request) const
|
|
{
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
if (!endpointOutcome.isSuccess())
|
|
return UpdateServiceLabelOutcome(endpointOutcome.error());
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
if (outcome.isSuccess())
|
|
return UpdateServiceLabelOutcome(UpdateServiceLabelResult(outcome.result()));
|
|
else
|
|
return UpdateServiceLabelOutcome(outcome.error());
|
|
}
|
|
|
|
void EasClient::updateServiceLabelAsync(const UpdateServiceLabelRequest& request, const UpdateServiceLabelAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
{
|
|
auto fn = [this, request, handler, context]()
|
|
{
|
|
handler(this, request, updateServiceLabel(request), context);
|
|
};
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
}
|
|
|
|
EasClient::UpdateServiceLabelOutcomeCallable EasClient::updateServiceLabelCallable(const UpdateServiceLabelRequest &request) const
|
|
{
|
|
auto task = std::make_shared<std::packaged_task<UpdateServiceLabelOutcome()>>(
|
|
[this, request]()
|
|
{
|
|
return this->updateServiceLabel(request);
|
|
});
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
return task->get_future();
|
|
}
|
|
|
|
EasClient::UpdateServiceMirrorOutcome EasClient::updateServiceMirror(const UpdateServiceMirrorRequest &request) const
|
|
{
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
if (!endpointOutcome.isSuccess())
|
|
return UpdateServiceMirrorOutcome(endpointOutcome.error());
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
if (outcome.isSuccess())
|
|
return UpdateServiceMirrorOutcome(UpdateServiceMirrorResult(outcome.result()));
|
|
else
|
|
return UpdateServiceMirrorOutcome(outcome.error());
|
|
}
|
|
|
|
void EasClient::updateServiceMirrorAsync(const UpdateServiceMirrorRequest& request, const UpdateServiceMirrorAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
{
|
|
auto fn = [this, request, handler, context]()
|
|
{
|
|
handler(this, request, updateServiceMirror(request), context);
|
|
};
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
}
|
|
|
|
EasClient::UpdateServiceMirrorOutcomeCallable EasClient::updateServiceMirrorCallable(const UpdateServiceMirrorRequest &request) const
|
|
{
|
|
auto task = std::make_shared<std::packaged_task<UpdateServiceMirrorOutcome()>>(
|
|
[this, request]()
|
|
{
|
|
return this->updateServiceMirror(request);
|
|
});
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
return task->get_future();
|
|
}
|
|
|
|
EasClient::UpdateServiceSafetyLockOutcome EasClient::updateServiceSafetyLock(const UpdateServiceSafetyLockRequest &request) const
|
|
{
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
if (!endpointOutcome.isSuccess())
|
|
return UpdateServiceSafetyLockOutcome(endpointOutcome.error());
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
if (outcome.isSuccess())
|
|
return UpdateServiceSafetyLockOutcome(UpdateServiceSafetyLockResult(outcome.result()));
|
|
else
|
|
return UpdateServiceSafetyLockOutcome(outcome.error());
|
|
}
|
|
|
|
void EasClient::updateServiceSafetyLockAsync(const UpdateServiceSafetyLockRequest& request, const UpdateServiceSafetyLockAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
{
|
|
auto fn = [this, request, handler, context]()
|
|
{
|
|
handler(this, request, updateServiceSafetyLock(request), context);
|
|
};
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
}
|
|
|
|
EasClient::UpdateServiceSafetyLockOutcomeCallable EasClient::updateServiceSafetyLockCallable(const UpdateServiceSafetyLockRequest &request) const
|
|
{
|
|
auto task = std::make_shared<std::packaged_task<UpdateServiceSafetyLockOutcome()>>(
|
|
[this, request]()
|
|
{
|
|
return this->updateServiceSafetyLock(request);
|
|
});
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
return task->get_future();
|
|
}
|
|
|
|
EasClient::UpdateServiceVersionOutcome EasClient::updateServiceVersion(const UpdateServiceVersionRequest &request) const
|
|
{
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
if (!endpointOutcome.isSuccess())
|
|
return UpdateServiceVersionOutcome(endpointOutcome.error());
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
if (outcome.isSuccess())
|
|
return UpdateServiceVersionOutcome(UpdateServiceVersionResult(outcome.result()));
|
|
else
|
|
return UpdateServiceVersionOutcome(outcome.error());
|
|
}
|
|
|
|
void EasClient::updateServiceVersionAsync(const UpdateServiceVersionRequest& request, const UpdateServiceVersionAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
{
|
|
auto fn = [this, request, handler, context]()
|
|
{
|
|
handler(this, request, updateServiceVersion(request), context);
|
|
};
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
}
|
|
|
|
EasClient::UpdateServiceVersionOutcomeCallable EasClient::updateServiceVersionCallable(const UpdateServiceVersionRequest &request) const
|
|
{
|
|
auto task = std::make_shared<std::packaged_task<UpdateServiceVersionOutcome()>>(
|
|
[this, request]()
|
|
{
|
|
return this->updateServiceVersion(request);
|
|
});
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
return task->get_future();
|
|
}
|
|
|