1242 lines
40 KiB
C++
1242 lines
40 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, "");
|
|
}
|
|
|
|
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, "");
|
|
}
|
|
|
|
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, "");
|
|
}
|
|
|
|
EasClient::~EasClient()
|
|
{}
|
|
|
|
EasClient::CheckServiceExistsOutcome EasClient::checkServiceExists(const CheckServiceExistsRequest &request) const
|
|
{
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
if (!endpointOutcome.isSuccess())
|
|
return CheckServiceExistsOutcome(endpointOutcome.error());
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
if (outcome.isSuccess())
|
|
return CheckServiceExistsOutcome(CheckServiceExistsResult(outcome.result()));
|
|
else
|
|
return CheckServiceExistsOutcome(outcome.error());
|
|
}
|
|
|
|
void EasClient::checkServiceExistsAsync(const CheckServiceExistsRequest& request, const CheckServiceExistsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
{
|
|
auto fn = [this, request, handler, context]()
|
|
{
|
|
handler(this, request, checkServiceExists(request), context);
|
|
};
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
}
|
|
|
|
EasClient::CheckServiceExistsOutcomeCallable EasClient::checkServiceExistsCallable(const CheckServiceExistsRequest &request) const
|
|
{
|
|
auto task = std::make_shared<std::packaged_task<CheckServiceExistsOutcome()>>(
|
|
[this, request]()
|
|
{
|
|
return this->checkServiceExists(request);
|
|
});
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
return task->get_future();
|
|
}
|
|
|
|
EasClient::CreateNetworkInterfaceOutcome EasClient::createNetworkInterface(const CreateNetworkInterfaceRequest &request) const
|
|
{
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
if (!endpointOutcome.isSuccess())
|
|
return CreateNetworkInterfaceOutcome(endpointOutcome.error());
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
if (outcome.isSuccess())
|
|
return CreateNetworkInterfaceOutcome(CreateNetworkInterfaceResult(outcome.result()));
|
|
else
|
|
return CreateNetworkInterfaceOutcome(outcome.error());
|
|
}
|
|
|
|
void EasClient::createNetworkInterfaceAsync(const CreateNetworkInterfaceRequest& request, const CreateNetworkInterfaceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
{
|
|
auto fn = [this, request, handler, context]()
|
|
{
|
|
handler(this, request, createNetworkInterface(request), context);
|
|
};
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
}
|
|
|
|
EasClient::CreateNetworkInterfaceOutcomeCallable EasClient::createNetworkInterfaceCallable(const CreateNetworkInterfaceRequest &request) const
|
|
{
|
|
auto task = std::make_shared<std::packaged_task<CreateNetworkInterfaceOutcome()>>(
|
|
[this, request]()
|
|
{
|
|
return this->createNetworkInterface(request);
|
|
});
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
return task->get_future();
|
|
}
|
|
|
|
EasClient::CreateSLSOutcome EasClient::createSLS(const CreateSLSRequest &request) const
|
|
{
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
if (!endpointOutcome.isSuccess())
|
|
return CreateSLSOutcome(endpointOutcome.error());
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
if (outcome.isSuccess())
|
|
return CreateSLSOutcome(CreateSLSResult(outcome.result()));
|
|
else
|
|
return CreateSLSOutcome(outcome.error());
|
|
}
|
|
|
|
void EasClient::createSLSAsync(const CreateSLSRequest& request, const CreateSLSAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
{
|
|
auto fn = [this, request, handler, context]()
|
|
{
|
|
handler(this, request, createSLS(request), context);
|
|
};
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
}
|
|
|
|
EasClient::CreateSLSOutcomeCallable EasClient::createSLSCallable(const CreateSLSRequest &request) const
|
|
{
|
|
auto task = std::make_shared<std::packaged_task<CreateSLSOutcome()>>(
|
|
[this, request]()
|
|
{
|
|
return this->createSLS(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::CreateTaskOutcome EasClient::createTask(const CreateTaskRequest &request) const
|
|
{
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
if (!endpointOutcome.isSuccess())
|
|
return CreateTaskOutcome(endpointOutcome.error());
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
if (outcome.isSuccess())
|
|
return CreateTaskOutcome(CreateTaskResult(outcome.result()));
|
|
else
|
|
return CreateTaskOutcome(outcome.error());
|
|
}
|
|
|
|
void EasClient::createTaskAsync(const CreateTaskRequest& request, const CreateTaskAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
{
|
|
auto fn = [this, request, handler, context]()
|
|
{
|
|
handler(this, request, createTask(request), context);
|
|
};
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
}
|
|
|
|
EasClient::CreateTaskOutcomeCallable EasClient::createTaskCallable(const CreateTaskRequest &request) const
|
|
{
|
|
auto task = std::make_shared<std::packaged_task<CreateTaskOutcome()>>(
|
|
[this, request]()
|
|
{
|
|
return this->createTask(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::DeleteResourceInstanceOutcome EasClient::deleteResourceInstance(const DeleteResourceInstanceRequest &request) const
|
|
{
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
if (!endpointOutcome.isSuccess())
|
|
return DeleteResourceInstanceOutcome(endpointOutcome.error());
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
if (outcome.isSuccess())
|
|
return DeleteResourceInstanceOutcome(DeleteResourceInstanceResult(outcome.result()));
|
|
else
|
|
return DeleteResourceInstanceOutcome(outcome.error());
|
|
}
|
|
|
|
void EasClient::deleteResourceInstanceAsync(const DeleteResourceInstanceRequest& request, const DeleteResourceInstanceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
{
|
|
auto fn = [this, request, handler, context]()
|
|
{
|
|
handler(this, request, deleteResourceInstance(request), context);
|
|
};
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
}
|
|
|
|
EasClient::DeleteResourceInstanceOutcomeCallable EasClient::deleteResourceInstanceCallable(const DeleteResourceInstanceRequest &request) const
|
|
{
|
|
auto task = std::make_shared<std::packaged_task<DeleteResourceInstanceOutcome()>>(
|
|
[this, request]()
|
|
{
|
|
return this->deleteResourceInstance(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::DeleteTaskOutcome EasClient::deleteTask(const DeleteTaskRequest &request) const
|
|
{
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
if (!endpointOutcome.isSuccess())
|
|
return DeleteTaskOutcome(endpointOutcome.error());
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
if (outcome.isSuccess())
|
|
return DeleteTaskOutcome(DeleteTaskResult(outcome.result()));
|
|
else
|
|
return DeleteTaskOutcome(outcome.error());
|
|
}
|
|
|
|
void EasClient::deleteTaskAsync(const DeleteTaskRequest& request, const DeleteTaskAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
{
|
|
auto fn = [this, request, handler, context]()
|
|
{
|
|
handler(this, request, deleteTask(request), context);
|
|
};
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
}
|
|
|
|
EasClient::DeleteTaskOutcomeCallable EasClient::deleteTaskCallable(const DeleteTaskRequest &request) const
|
|
{
|
|
auto task = std::make_shared<std::packaged_task<DeleteTaskOutcome()>>(
|
|
[this, request]()
|
|
{
|
|
return this->deleteTask(request);
|
|
});
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
return task->get_future();
|
|
}
|
|
|
|
EasClient::GetAvailableRegionsOutcome EasClient::getAvailableRegions(const GetAvailableRegionsRequest &request) const
|
|
{
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
if (!endpointOutcome.isSuccess())
|
|
return GetAvailableRegionsOutcome(endpointOutcome.error());
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
if (outcome.isSuccess())
|
|
return GetAvailableRegionsOutcome(GetAvailableRegionsResult(outcome.result()));
|
|
else
|
|
return GetAvailableRegionsOutcome(outcome.error());
|
|
}
|
|
|
|
void EasClient::getAvailableRegionsAsync(const GetAvailableRegionsRequest& request, const GetAvailableRegionsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
{
|
|
auto fn = [this, request, handler, context]()
|
|
{
|
|
handler(this, request, getAvailableRegions(request), context);
|
|
};
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
}
|
|
|
|
EasClient::GetAvailableRegionsOutcomeCallable EasClient::getAvailableRegionsCallable(const GetAvailableRegionsRequest &request) const
|
|
{
|
|
auto task = std::make_shared<std::packaged_task<GetAvailableRegionsOutcome()>>(
|
|
[this, request]()
|
|
{
|
|
return this->getAvailableRegions(request);
|
|
});
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
return task->get_future();
|
|
}
|
|
|
|
EasClient::GetNetworkInterfaceOutcome EasClient::getNetworkInterface(const GetNetworkInterfaceRequest &request) const
|
|
{
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
if (!endpointOutcome.isSuccess())
|
|
return GetNetworkInterfaceOutcome(endpointOutcome.error());
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
if (outcome.isSuccess())
|
|
return GetNetworkInterfaceOutcome(GetNetworkInterfaceResult(outcome.result()));
|
|
else
|
|
return GetNetworkInterfaceOutcome(outcome.error());
|
|
}
|
|
|
|
void EasClient::getNetworkInterfaceAsync(const GetNetworkInterfaceRequest& request, const GetNetworkInterfaceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
{
|
|
auto fn = [this, request, handler, context]()
|
|
{
|
|
handler(this, request, getNetworkInterface(request), context);
|
|
};
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
}
|
|
|
|
EasClient::GetNetworkInterfaceOutcomeCallable EasClient::getNetworkInterfaceCallable(const GetNetworkInterfaceRequest &request) const
|
|
{
|
|
auto task = std::make_shared<std::packaged_task<GetNetworkInterfaceOutcome()>>(
|
|
[this, request]()
|
|
{
|
|
return this->getNetworkInterface(request);
|
|
});
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
return task->get_future();
|
|
}
|
|
|
|
EasClient::GetOrCreateResourceOutcome EasClient::getOrCreateResource(const GetOrCreateResourceRequest &request) const
|
|
{
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
if (!endpointOutcome.isSuccess())
|
|
return GetOrCreateResourceOutcome(endpointOutcome.error());
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
if (outcome.isSuccess())
|
|
return GetOrCreateResourceOutcome(GetOrCreateResourceResult(outcome.result()));
|
|
else
|
|
return GetOrCreateResourceOutcome(outcome.error());
|
|
}
|
|
|
|
void EasClient::getOrCreateResourceAsync(const GetOrCreateResourceRequest& request, const GetOrCreateResourceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
{
|
|
auto fn = [this, request, handler, context]()
|
|
{
|
|
handler(this, request, getOrCreateResource(request), context);
|
|
};
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
}
|
|
|
|
EasClient::GetOrCreateResourceOutcomeCallable EasClient::getOrCreateResourceCallable(const GetOrCreateResourceRequest &request) const
|
|
{
|
|
auto task = std::make_shared<std::packaged_task<GetOrCreateResourceOutcome()>>(
|
|
[this, request]()
|
|
{
|
|
return this->getOrCreateResource(request);
|
|
});
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
return task->get_future();
|
|
}
|
|
|
|
EasClient::GetOssAuthorizeOutcome EasClient::getOssAuthorize(const GetOssAuthorizeRequest &request) const
|
|
{
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
if (!endpointOutcome.isSuccess())
|
|
return GetOssAuthorizeOutcome(endpointOutcome.error());
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
if (outcome.isSuccess())
|
|
return GetOssAuthorizeOutcome(GetOssAuthorizeResult(outcome.result()));
|
|
else
|
|
return GetOssAuthorizeOutcome(outcome.error());
|
|
}
|
|
|
|
void EasClient::getOssAuthorizeAsync(const GetOssAuthorizeRequest& request, const GetOssAuthorizeAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
{
|
|
auto fn = [this, request, handler, context]()
|
|
{
|
|
handler(this, request, getOssAuthorize(request), context);
|
|
};
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
}
|
|
|
|
EasClient::GetOssAuthorizeOutcomeCallable EasClient::getOssAuthorizeCallable(const GetOssAuthorizeRequest &request) const
|
|
{
|
|
auto task = std::make_shared<std::packaged_task<GetOssAuthorizeOutcome()>>(
|
|
[this, request]()
|
|
{
|
|
return this->getOssAuthorize(request);
|
|
});
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
return task->get_future();
|
|
}
|
|
|
|
EasClient::GetResourceInstancesOutcome EasClient::getResourceInstances(const GetResourceInstancesRequest &request) const
|
|
{
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
if (!endpointOutcome.isSuccess())
|
|
return GetResourceInstancesOutcome(endpointOutcome.error());
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
if (outcome.isSuccess())
|
|
return GetResourceInstancesOutcome(GetResourceInstancesResult(outcome.result()));
|
|
else
|
|
return GetResourceInstancesOutcome(outcome.error());
|
|
}
|
|
|
|
void EasClient::getResourceInstancesAsync(const GetResourceInstancesRequest& request, const GetResourceInstancesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
{
|
|
auto fn = [this, request, handler, context]()
|
|
{
|
|
handler(this, request, getResourceInstances(request), context);
|
|
};
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
}
|
|
|
|
EasClient::GetResourceInstancesOutcomeCallable EasClient::getResourceInstancesCallable(const GetResourceInstancesRequest &request) const
|
|
{
|
|
auto task = std::make_shared<std::packaged_task<GetResourceInstancesOutcome()>>(
|
|
[this, request]()
|
|
{
|
|
return this->getResourceInstances(request);
|
|
});
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
return task->get_future();
|
|
}
|
|
|
|
EasClient::GetResourcePodsOutcome EasClient::getResourcePods(const GetResourcePodsRequest &request) const
|
|
{
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
if (!endpointOutcome.isSuccess())
|
|
return GetResourcePodsOutcome(endpointOutcome.error());
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
if (outcome.isSuccess())
|
|
return GetResourcePodsOutcome(GetResourcePodsResult(outcome.result()));
|
|
else
|
|
return GetResourcePodsOutcome(outcome.error());
|
|
}
|
|
|
|
void EasClient::getResourcePodsAsync(const GetResourcePodsRequest& request, const GetResourcePodsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
{
|
|
auto fn = [this, request, handler, context]()
|
|
{
|
|
handler(this, request, getResourcePods(request), context);
|
|
};
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
}
|
|
|
|
EasClient::GetResourcePodsOutcomeCallable EasClient::getResourcePodsCallable(const GetResourcePodsRequest &request) const
|
|
{
|
|
auto task = std::make_shared<std::packaged_task<GetResourcePodsOutcome()>>(
|
|
[this, request]()
|
|
{
|
|
return this->getResourcePods(request);
|
|
});
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
return task->get_future();
|
|
}
|
|
|
|
EasClient::GetResourceServicesOutcome EasClient::getResourceServices(const GetResourceServicesRequest &request) const
|
|
{
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
if (!endpointOutcome.isSuccess())
|
|
return GetResourceServicesOutcome(endpointOutcome.error());
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
if (outcome.isSuccess())
|
|
return GetResourceServicesOutcome(GetResourceServicesResult(outcome.result()));
|
|
else
|
|
return GetResourceServicesOutcome(outcome.error());
|
|
}
|
|
|
|
void EasClient::getResourceServicesAsync(const GetResourceServicesRequest& request, const GetResourceServicesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
{
|
|
auto fn = [this, request, handler, context]()
|
|
{
|
|
handler(this, request, getResourceServices(request), context);
|
|
};
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
}
|
|
|
|
EasClient::GetResourceServicesOutcomeCallable EasClient::getResourceServicesCallable(const GetResourceServicesRequest &request) const
|
|
{
|
|
auto task = std::make_shared<std::packaged_task<GetResourceServicesOutcome()>>(
|
|
[this, request]()
|
|
{
|
|
return this->getResourceServices(request);
|
|
});
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
return task->get_future();
|
|
}
|
|
|
|
EasClient::GetResourceStatusOutcome EasClient::getResourceStatus(const GetResourceStatusRequest &request) const
|
|
{
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
if (!endpointOutcome.isSuccess())
|
|
return GetResourceStatusOutcome(endpointOutcome.error());
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
if (outcome.isSuccess())
|
|
return GetResourceStatusOutcome(GetResourceStatusResult(outcome.result()));
|
|
else
|
|
return GetResourceStatusOutcome(outcome.error());
|
|
}
|
|
|
|
void EasClient::getResourceStatusAsync(const GetResourceStatusRequest& request, const GetResourceStatusAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
{
|
|
auto fn = [this, request, handler, context]()
|
|
{
|
|
handler(this, request, getResourceStatus(request), context);
|
|
};
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
}
|
|
|
|
EasClient::GetResourceStatusOutcomeCallable EasClient::getResourceStatusCallable(const GetResourceStatusRequest &request) const
|
|
{
|
|
auto task = std::make_shared<std::packaged_task<GetResourceStatusOutcome()>>(
|
|
[this, request]()
|
|
{
|
|
return this->getResourceStatus(request);
|
|
});
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
return task->get_future();
|
|
}
|
|
|
|
EasClient::GetServiceOutcome EasClient::getService(const GetServiceRequest &request) const
|
|
{
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
if (!endpointOutcome.isSuccess())
|
|
return GetServiceOutcome(endpointOutcome.error());
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
if (outcome.isSuccess())
|
|
return GetServiceOutcome(GetServiceResult(outcome.result()));
|
|
else
|
|
return GetServiceOutcome(outcome.error());
|
|
}
|
|
|
|
void EasClient::getServiceAsync(const GetServiceRequest& request, const GetServiceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
{
|
|
auto fn = [this, request, handler, context]()
|
|
{
|
|
handler(this, request, getService(request), context);
|
|
};
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
}
|
|
|
|
EasClient::GetServiceOutcomeCallable EasClient::getServiceCallable(const GetServiceRequest &request) const
|
|
{
|
|
auto task = std::make_shared<std::packaged_task<GetServiceOutcome()>>(
|
|
[this, request]()
|
|
{
|
|
return this->getService(request);
|
|
});
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
return task->get_future();
|
|
}
|
|
|
|
EasClient::GetServiceRegionOutcome EasClient::getServiceRegion(const GetServiceRegionRequest &request) const
|
|
{
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
if (!endpointOutcome.isSuccess())
|
|
return GetServiceRegionOutcome(endpointOutcome.error());
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
if (outcome.isSuccess())
|
|
return GetServiceRegionOutcome(GetServiceRegionResult(outcome.result()));
|
|
else
|
|
return GetServiceRegionOutcome(outcome.error());
|
|
}
|
|
|
|
void EasClient::getServiceRegionAsync(const GetServiceRegionRequest& request, const GetServiceRegionAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
{
|
|
auto fn = [this, request, handler, context]()
|
|
{
|
|
handler(this, request, getServiceRegion(request), context);
|
|
};
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
}
|
|
|
|
EasClient::GetServiceRegionOutcomeCallable EasClient::getServiceRegionCallable(const GetServiceRegionRequest &request) const
|
|
{
|
|
auto task = std::make_shared<std::packaged_task<GetServiceRegionOutcome()>>(
|
|
[this, request]()
|
|
{
|
|
return this->getServiceRegion(request);
|
|
});
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
return task->get_future();
|
|
}
|
|
|
|
EasClient::GetServiceStatisticsOutcome EasClient::getServiceStatistics(const GetServiceStatisticsRequest &request) const
|
|
{
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
if (!endpointOutcome.isSuccess())
|
|
return GetServiceStatisticsOutcome(endpointOutcome.error());
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
if (outcome.isSuccess())
|
|
return GetServiceStatisticsOutcome(GetServiceStatisticsResult(outcome.result()));
|
|
else
|
|
return GetServiceStatisticsOutcome(outcome.error());
|
|
}
|
|
|
|
void EasClient::getServiceStatisticsAsync(const GetServiceStatisticsRequest& request, const GetServiceStatisticsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
{
|
|
auto fn = [this, request, handler, context]()
|
|
{
|
|
handler(this, request, getServiceStatistics(request), context);
|
|
};
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
}
|
|
|
|
EasClient::GetServiceStatisticsOutcomeCallable EasClient::getServiceStatisticsCallable(const GetServiceStatisticsRequest &request) const
|
|
{
|
|
auto task = std::make_shared<std::packaged_task<GetServiceStatisticsOutcome()>>(
|
|
[this, request]()
|
|
{
|
|
return this->getServiceStatistics(request);
|
|
});
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
return task->get_future();
|
|
}
|
|
|
|
EasClient::GetServiceTokenOutcome EasClient::getServiceToken(const GetServiceTokenRequest &request) const
|
|
{
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
if (!endpointOutcome.isSuccess())
|
|
return GetServiceTokenOutcome(endpointOutcome.error());
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
if (outcome.isSuccess())
|
|
return GetServiceTokenOutcome(GetServiceTokenResult(outcome.result()));
|
|
else
|
|
return GetServiceTokenOutcome(outcome.error());
|
|
}
|
|
|
|
void EasClient::getServiceTokenAsync(const GetServiceTokenRequest& request, const GetServiceTokenAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
{
|
|
auto fn = [this, request, handler, context]()
|
|
{
|
|
handler(this, request, getServiceToken(request), context);
|
|
};
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
}
|
|
|
|
EasClient::GetServiceTokenOutcomeCallable EasClient::getServiceTokenCallable(const GetServiceTokenRequest &request) const
|
|
{
|
|
auto task = std::make_shared<std::packaged_task<GetServiceTokenOutcome()>>(
|
|
[this, request]()
|
|
{
|
|
return this->getServiceToken(request);
|
|
});
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
return task->get_future();
|
|
}
|
|
|
|
EasClient::GetServiceVersionOutcome EasClient::getServiceVersion(const GetServiceVersionRequest &request) const
|
|
{
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
if (!endpointOutcome.isSuccess())
|
|
return GetServiceVersionOutcome(endpointOutcome.error());
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
if (outcome.isSuccess())
|
|
return GetServiceVersionOutcome(GetServiceVersionResult(outcome.result()));
|
|
else
|
|
return GetServiceVersionOutcome(outcome.error());
|
|
}
|
|
|
|
void EasClient::getServiceVersionAsync(const GetServiceVersionRequest& request, const GetServiceVersionAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
{
|
|
auto fn = [this, request, handler, context]()
|
|
{
|
|
handler(this, request, getServiceVersion(request), context);
|
|
};
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
}
|
|
|
|
EasClient::GetServiceVersionOutcomeCallable EasClient::getServiceVersionCallable(const GetServiceVersionRequest &request) const
|
|
{
|
|
auto task = std::make_shared<std::packaged_task<GetServiceVersionOutcome()>>(
|
|
[this, request]()
|
|
{
|
|
return this->getServiceVersion(request);
|
|
});
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
return task->get_future();
|
|
}
|
|
|
|
EasClient::GetServiceWorkerOutcome EasClient::getServiceWorker(const GetServiceWorkerRequest &request) const
|
|
{
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
if (!endpointOutcome.isSuccess())
|
|
return GetServiceWorkerOutcome(endpointOutcome.error());
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
if (outcome.isSuccess())
|
|
return GetServiceWorkerOutcome(GetServiceWorkerResult(outcome.result()));
|
|
else
|
|
return GetServiceWorkerOutcome(outcome.error());
|
|
}
|
|
|
|
void EasClient::getServiceWorkerAsync(const GetServiceWorkerRequest& request, const GetServiceWorkerAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
{
|
|
auto fn = [this, request, handler, context]()
|
|
{
|
|
handler(this, request, getServiceWorker(request), context);
|
|
};
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
}
|
|
|
|
EasClient::GetServiceWorkerOutcomeCallable EasClient::getServiceWorkerCallable(const GetServiceWorkerRequest &request) const
|
|
{
|
|
auto task = std::make_shared<std::packaged_task<GetServiceWorkerOutcome()>>(
|
|
[this, request]()
|
|
{
|
|
return this->getServiceWorker(request);
|
|
});
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
return task->get_future();
|
|
}
|
|
|
|
EasClient::GetTaskOutcome EasClient::getTask(const GetTaskRequest &request) const
|
|
{
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
if (!endpointOutcome.isSuccess())
|
|
return GetTaskOutcome(endpointOutcome.error());
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
if (outcome.isSuccess())
|
|
return GetTaskOutcome(GetTaskResult(outcome.result()));
|
|
else
|
|
return GetTaskOutcome(outcome.error());
|
|
}
|
|
|
|
void EasClient::getTaskAsync(const GetTaskRequest& request, const GetTaskAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
{
|
|
auto fn = [this, request, handler, context]()
|
|
{
|
|
handler(this, request, getTask(request), context);
|
|
};
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
}
|
|
|
|
EasClient::GetTaskOutcomeCallable EasClient::getTaskCallable(const GetTaskRequest &request) const
|
|
{
|
|
auto task = std::make_shared<std::packaged_task<GetTaskOutcome()>>(
|
|
[this, request]()
|
|
{
|
|
return this->getTask(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::ListTasksOutcome EasClient::listTasks(const ListTasksRequest &request) const
|
|
{
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
if (!endpointOutcome.isSuccess())
|
|
return ListTasksOutcome(endpointOutcome.error());
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
if (outcome.isSuccess())
|
|
return ListTasksOutcome(ListTasksResult(outcome.result()));
|
|
else
|
|
return ListTasksOutcome(outcome.error());
|
|
}
|
|
|
|
void EasClient::listTasksAsync(const ListTasksRequest& request, const ListTasksAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
{
|
|
auto fn = [this, request, handler, context]()
|
|
{
|
|
handler(this, request, listTasks(request), context);
|
|
};
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
}
|
|
|
|
EasClient::ListTasksOutcomeCallable EasClient::listTasksCallable(const ListTasksRequest &request) const
|
|
{
|
|
auto task = std::make_shared<std::packaged_task<ListTasksOutcome()>>(
|
|
[this, request]()
|
|
{
|
|
return this->listTasks(request);
|
|
});
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
return task->get_future();
|
|
}
|
|
|
|
EasClient::ListVIndexOutcome EasClient::listVIndex(const ListVIndexRequest &request) const
|
|
{
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
if (!endpointOutcome.isSuccess())
|
|
return ListVIndexOutcome(endpointOutcome.error());
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
if (outcome.isSuccess())
|
|
return ListVIndexOutcome(ListVIndexResult(outcome.result()));
|
|
else
|
|
return ListVIndexOutcome(outcome.error());
|
|
}
|
|
|
|
void EasClient::listVIndexAsync(const ListVIndexRequest& request, const ListVIndexAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
{
|
|
auto fn = [this, request, handler, context]()
|
|
{
|
|
handler(this, request, listVIndex(request), context);
|
|
};
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
}
|
|
|
|
EasClient::ListVIndexOutcomeCallable EasClient::listVIndexCallable(const ListVIndexRequest &request) const
|
|
{
|
|
auto task = std::make_shared<std::packaged_task<ListVIndexOutcome()>>(
|
|
[this, request]()
|
|
{
|
|
return this->listVIndex(request);
|
|
});
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
return task->get_future();
|
|
}
|
|
|
|
EasClient::ModifyServiceOutcome EasClient::modifyService(const ModifyServiceRequest &request) const
|
|
{
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
if (!endpointOutcome.isSuccess())
|
|
return ModifyServiceOutcome(endpointOutcome.error());
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
if (outcome.isSuccess())
|
|
return ModifyServiceOutcome(ModifyServiceResult(outcome.result()));
|
|
else
|
|
return ModifyServiceOutcome(outcome.error());
|
|
}
|
|
|
|
void EasClient::modifyServiceAsync(const ModifyServiceRequest& request, const ModifyServiceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
{
|
|
auto fn = [this, request, handler, context]()
|
|
{
|
|
handler(this, request, modifyService(request), context);
|
|
};
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
}
|
|
|
|
EasClient::ModifyServiceOutcomeCallable EasClient::modifyServiceCallable(const ModifyServiceRequest &request) const
|
|
{
|
|
auto task = std::make_shared<std::packaged_task<ModifyServiceOutcome()>>(
|
|
[this, request]()
|
|
{
|
|
return this->modifyService(request);
|
|
});
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
return task->get_future();
|
|
}
|
|
|
|
EasClient::ModifyServiceVersionOutcome EasClient::modifyServiceVersion(const ModifyServiceVersionRequest &request) const
|
|
{
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
if (!endpointOutcome.isSuccess())
|
|
return ModifyServiceVersionOutcome(endpointOutcome.error());
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
if (outcome.isSuccess())
|
|
return ModifyServiceVersionOutcome(ModifyServiceVersionResult(outcome.result()));
|
|
else
|
|
return ModifyServiceVersionOutcome(outcome.error());
|
|
}
|
|
|
|
void EasClient::modifyServiceVersionAsync(const ModifyServiceVersionRequest& request, const ModifyServiceVersionAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
{
|
|
auto fn = [this, request, handler, context]()
|
|
{
|
|
handler(this, request, modifyServiceVersion(request), context);
|
|
};
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
}
|
|
|
|
EasClient::ModifyServiceVersionOutcomeCallable EasClient::modifyServiceVersionCallable(const ModifyServiceVersionRequest &request) const
|
|
{
|
|
auto task = std::make_shared<std::packaged_task<ModifyServiceVersionOutcome()>>(
|
|
[this, request]()
|
|
{
|
|
return this->modifyServiceVersion(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::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::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::SyncServiceOutcome EasClient::syncService(const SyncServiceRequest &request) const
|
|
{
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
if (!endpointOutcome.isSuccess())
|
|
return SyncServiceOutcome(endpointOutcome.error());
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
if (outcome.isSuccess())
|
|
return SyncServiceOutcome(SyncServiceResult(outcome.result()));
|
|
else
|
|
return SyncServiceOutcome(outcome.error());
|
|
}
|
|
|
|
void EasClient::syncServiceAsync(const SyncServiceRequest& request, const SyncServiceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
{
|
|
auto fn = [this, request, handler, context]()
|
|
{
|
|
handler(this, request, syncService(request), context);
|
|
};
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
}
|
|
|
|
EasClient::SyncServiceOutcomeCallable EasClient::syncServiceCallable(const SyncServiceRequest &request) const
|
|
{
|
|
auto task = std::make_shared<std::packaged_task<SyncServiceOutcome()>>(
|
|
[this, request]()
|
|
{
|
|
return this->syncService(request);
|
|
});
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
return task->get_future();
|
|
}
|
|
|