954 lines
35 KiB
C++
954 lines
35 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/appstream-center/Appstream_centerClient.h>
|
|
#include <alibabacloud/core/SimpleCredentialsProvider.h>
|
|
|
|
using namespace AlibabaCloud;
|
|
using namespace AlibabaCloud::Location;
|
|
using namespace AlibabaCloud::Appstream_center;
|
|
using namespace AlibabaCloud::Appstream_center::Model;
|
|
|
|
namespace
|
|
{
|
|
const std::string SERVICE_NAME = "appstream-center";
|
|
}
|
|
|
|
Appstream_centerClient::Appstream_centerClient(const Credentials &credentials, const ClientConfiguration &configuration) :
|
|
RpcServiceClient(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, "");
|
|
}
|
|
|
|
Appstream_centerClient::Appstream_centerClient(const std::shared_ptr<CredentialsProvider>& credentialsProvider, const ClientConfiguration & configuration) :
|
|
RpcServiceClient(SERVICE_NAME, credentialsProvider, configuration)
|
|
{
|
|
auto locationClient = std::make_shared<LocationClient>(credentialsProvider, configuration);
|
|
endpointProvider_ = std::make_shared<EndpointProvider>(locationClient, configuration.regionId(), SERVICE_NAME, "");
|
|
}
|
|
|
|
Appstream_centerClient::Appstream_centerClient(const std::string & accessKeyId, const std::string & accessKeySecret, const ClientConfiguration & configuration) :
|
|
RpcServiceClient(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, "");
|
|
}
|
|
|
|
Appstream_centerClient::~Appstream_centerClient()
|
|
{}
|
|
|
|
Appstream_centerClient::ApproveOtaTaskOutcome Appstream_centerClient::approveOtaTask(const ApproveOtaTaskRequest &request) const
|
|
{
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
if (!endpointOutcome.isSuccess())
|
|
return ApproveOtaTaskOutcome(endpointOutcome.error());
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
if (outcome.isSuccess())
|
|
return ApproveOtaTaskOutcome(ApproveOtaTaskResult(outcome.result()));
|
|
else
|
|
return ApproveOtaTaskOutcome(outcome.error());
|
|
}
|
|
|
|
void Appstream_centerClient::approveOtaTaskAsync(const ApproveOtaTaskRequest& request, const ApproveOtaTaskAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
{
|
|
auto fn = [this, request, handler, context]()
|
|
{
|
|
handler(this, request, approveOtaTask(request), context);
|
|
};
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
}
|
|
|
|
Appstream_centerClient::ApproveOtaTaskOutcomeCallable Appstream_centerClient::approveOtaTaskCallable(const ApproveOtaTaskRequest &request) const
|
|
{
|
|
auto task = std::make_shared<std::packaged_task<ApproveOtaTaskOutcome()>>(
|
|
[this, request]()
|
|
{
|
|
return this->approveOtaTask(request);
|
|
});
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
return task->get_future();
|
|
}
|
|
|
|
Appstream_centerClient::AuthorizeInstanceGroupOutcome Appstream_centerClient::authorizeInstanceGroup(const AuthorizeInstanceGroupRequest &request) const
|
|
{
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
if (!endpointOutcome.isSuccess())
|
|
return AuthorizeInstanceGroupOutcome(endpointOutcome.error());
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
if (outcome.isSuccess())
|
|
return AuthorizeInstanceGroupOutcome(AuthorizeInstanceGroupResult(outcome.result()));
|
|
else
|
|
return AuthorizeInstanceGroupOutcome(outcome.error());
|
|
}
|
|
|
|
void Appstream_centerClient::authorizeInstanceGroupAsync(const AuthorizeInstanceGroupRequest& request, const AuthorizeInstanceGroupAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
{
|
|
auto fn = [this, request, handler, context]()
|
|
{
|
|
handler(this, request, authorizeInstanceGroup(request), context);
|
|
};
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
}
|
|
|
|
Appstream_centerClient::AuthorizeInstanceGroupOutcomeCallable Appstream_centerClient::authorizeInstanceGroupCallable(const AuthorizeInstanceGroupRequest &request) const
|
|
{
|
|
auto task = std::make_shared<std::packaged_task<AuthorizeInstanceGroupOutcome()>>(
|
|
[this, request]()
|
|
{
|
|
return this->authorizeInstanceGroup(request);
|
|
});
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
return task->get_future();
|
|
}
|
|
|
|
Appstream_centerClient::CancelOtaTaskOutcome Appstream_centerClient::cancelOtaTask(const CancelOtaTaskRequest &request) const
|
|
{
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
if (!endpointOutcome.isSuccess())
|
|
return CancelOtaTaskOutcome(endpointOutcome.error());
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
if (outcome.isSuccess())
|
|
return CancelOtaTaskOutcome(CancelOtaTaskResult(outcome.result()));
|
|
else
|
|
return CancelOtaTaskOutcome(outcome.error());
|
|
}
|
|
|
|
void Appstream_centerClient::cancelOtaTaskAsync(const CancelOtaTaskRequest& request, const CancelOtaTaskAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
{
|
|
auto fn = [this, request, handler, context]()
|
|
{
|
|
handler(this, request, cancelOtaTask(request), context);
|
|
};
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
}
|
|
|
|
Appstream_centerClient::CancelOtaTaskOutcomeCallable Appstream_centerClient::cancelOtaTaskCallable(const CancelOtaTaskRequest &request) const
|
|
{
|
|
auto task = std::make_shared<std::packaged_task<CancelOtaTaskOutcome()>>(
|
|
[this, request]()
|
|
{
|
|
return this->cancelOtaTask(request);
|
|
});
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
return task->get_future();
|
|
}
|
|
|
|
Appstream_centerClient::CreateAppInstanceGroupOutcome Appstream_centerClient::createAppInstanceGroup(const CreateAppInstanceGroupRequest &request) const
|
|
{
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
if (!endpointOutcome.isSuccess())
|
|
return CreateAppInstanceGroupOutcome(endpointOutcome.error());
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
if (outcome.isSuccess())
|
|
return CreateAppInstanceGroupOutcome(CreateAppInstanceGroupResult(outcome.result()));
|
|
else
|
|
return CreateAppInstanceGroupOutcome(outcome.error());
|
|
}
|
|
|
|
void Appstream_centerClient::createAppInstanceGroupAsync(const CreateAppInstanceGroupRequest& request, const CreateAppInstanceGroupAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
{
|
|
auto fn = [this, request, handler, context]()
|
|
{
|
|
handler(this, request, createAppInstanceGroup(request), context);
|
|
};
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
}
|
|
|
|
Appstream_centerClient::CreateAppInstanceGroupOutcomeCallable Appstream_centerClient::createAppInstanceGroupCallable(const CreateAppInstanceGroupRequest &request) const
|
|
{
|
|
auto task = std::make_shared<std::packaged_task<CreateAppInstanceGroupOutcome()>>(
|
|
[this, request]()
|
|
{
|
|
return this->createAppInstanceGroup(request);
|
|
});
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
return task->get_future();
|
|
}
|
|
|
|
Appstream_centerClient::DeleteAppInstanceGroupOutcome Appstream_centerClient::deleteAppInstanceGroup(const DeleteAppInstanceGroupRequest &request) const
|
|
{
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
if (!endpointOutcome.isSuccess())
|
|
return DeleteAppInstanceGroupOutcome(endpointOutcome.error());
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
if (outcome.isSuccess())
|
|
return DeleteAppInstanceGroupOutcome(DeleteAppInstanceGroupResult(outcome.result()));
|
|
else
|
|
return DeleteAppInstanceGroupOutcome(outcome.error());
|
|
}
|
|
|
|
void Appstream_centerClient::deleteAppInstanceGroupAsync(const DeleteAppInstanceGroupRequest& request, const DeleteAppInstanceGroupAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
{
|
|
auto fn = [this, request, handler, context]()
|
|
{
|
|
handler(this, request, deleteAppInstanceGroup(request), context);
|
|
};
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
}
|
|
|
|
Appstream_centerClient::DeleteAppInstanceGroupOutcomeCallable Appstream_centerClient::deleteAppInstanceGroupCallable(const DeleteAppInstanceGroupRequest &request) const
|
|
{
|
|
auto task = std::make_shared<std::packaged_task<DeleteAppInstanceGroupOutcome()>>(
|
|
[this, request]()
|
|
{
|
|
return this->deleteAppInstanceGroup(request);
|
|
});
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
return task->get_future();
|
|
}
|
|
|
|
Appstream_centerClient::DeleteAppInstancesOutcome Appstream_centerClient::deleteAppInstances(const DeleteAppInstancesRequest &request) const
|
|
{
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
if (!endpointOutcome.isSuccess())
|
|
return DeleteAppInstancesOutcome(endpointOutcome.error());
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
if (outcome.isSuccess())
|
|
return DeleteAppInstancesOutcome(DeleteAppInstancesResult(outcome.result()));
|
|
else
|
|
return DeleteAppInstancesOutcome(outcome.error());
|
|
}
|
|
|
|
void Appstream_centerClient::deleteAppInstancesAsync(const DeleteAppInstancesRequest& request, const DeleteAppInstancesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
{
|
|
auto fn = [this, request, handler, context]()
|
|
{
|
|
handler(this, request, deleteAppInstances(request), context);
|
|
};
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
}
|
|
|
|
Appstream_centerClient::DeleteAppInstancesOutcomeCallable Appstream_centerClient::deleteAppInstancesCallable(const DeleteAppInstancesRequest &request) const
|
|
{
|
|
auto task = std::make_shared<std::packaged_task<DeleteAppInstancesOutcome()>>(
|
|
[this, request]()
|
|
{
|
|
return this->deleteAppInstances(request);
|
|
});
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
return task->get_future();
|
|
}
|
|
|
|
Appstream_centerClient::GetAppInstanceGroupOutcome Appstream_centerClient::getAppInstanceGroup(const GetAppInstanceGroupRequest &request) const
|
|
{
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
if (!endpointOutcome.isSuccess())
|
|
return GetAppInstanceGroupOutcome(endpointOutcome.error());
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
if (outcome.isSuccess())
|
|
return GetAppInstanceGroupOutcome(GetAppInstanceGroupResult(outcome.result()));
|
|
else
|
|
return GetAppInstanceGroupOutcome(outcome.error());
|
|
}
|
|
|
|
void Appstream_centerClient::getAppInstanceGroupAsync(const GetAppInstanceGroupRequest& request, const GetAppInstanceGroupAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
{
|
|
auto fn = [this, request, handler, context]()
|
|
{
|
|
handler(this, request, getAppInstanceGroup(request), context);
|
|
};
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
}
|
|
|
|
Appstream_centerClient::GetAppInstanceGroupOutcomeCallable Appstream_centerClient::getAppInstanceGroupCallable(const GetAppInstanceGroupRequest &request) const
|
|
{
|
|
auto task = std::make_shared<std::packaged_task<GetAppInstanceGroupOutcome()>>(
|
|
[this, request]()
|
|
{
|
|
return this->getAppInstanceGroup(request);
|
|
});
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
return task->get_future();
|
|
}
|
|
|
|
Appstream_centerClient::GetConnectionTicketOutcome Appstream_centerClient::getConnectionTicket(const GetConnectionTicketRequest &request) const
|
|
{
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
if (!endpointOutcome.isSuccess())
|
|
return GetConnectionTicketOutcome(endpointOutcome.error());
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
if (outcome.isSuccess())
|
|
return GetConnectionTicketOutcome(GetConnectionTicketResult(outcome.result()));
|
|
else
|
|
return GetConnectionTicketOutcome(outcome.error());
|
|
}
|
|
|
|
void Appstream_centerClient::getConnectionTicketAsync(const GetConnectionTicketRequest& request, const GetConnectionTicketAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
{
|
|
auto fn = [this, request, handler, context]()
|
|
{
|
|
handler(this, request, getConnectionTicket(request), context);
|
|
};
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
}
|
|
|
|
Appstream_centerClient::GetConnectionTicketOutcomeCallable Appstream_centerClient::getConnectionTicketCallable(const GetConnectionTicketRequest &request) const
|
|
{
|
|
auto task = std::make_shared<std::packaged_task<GetConnectionTicketOutcome()>>(
|
|
[this, request]()
|
|
{
|
|
return this->getConnectionTicket(request);
|
|
});
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
return task->get_future();
|
|
}
|
|
|
|
Appstream_centerClient::GetOtaTaskByTaskIdOutcome Appstream_centerClient::getOtaTaskByTaskId(const GetOtaTaskByTaskIdRequest &request) const
|
|
{
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
if (!endpointOutcome.isSuccess())
|
|
return GetOtaTaskByTaskIdOutcome(endpointOutcome.error());
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
if (outcome.isSuccess())
|
|
return GetOtaTaskByTaskIdOutcome(GetOtaTaskByTaskIdResult(outcome.result()));
|
|
else
|
|
return GetOtaTaskByTaskIdOutcome(outcome.error());
|
|
}
|
|
|
|
void Appstream_centerClient::getOtaTaskByTaskIdAsync(const GetOtaTaskByTaskIdRequest& request, const GetOtaTaskByTaskIdAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
{
|
|
auto fn = [this, request, handler, context]()
|
|
{
|
|
handler(this, request, getOtaTaskByTaskId(request), context);
|
|
};
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
}
|
|
|
|
Appstream_centerClient::GetOtaTaskByTaskIdOutcomeCallable Appstream_centerClient::getOtaTaskByTaskIdCallable(const GetOtaTaskByTaskIdRequest &request) const
|
|
{
|
|
auto task = std::make_shared<std::packaged_task<GetOtaTaskByTaskIdOutcome()>>(
|
|
[this, request]()
|
|
{
|
|
return this->getOtaTaskByTaskId(request);
|
|
});
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
return task->get_future();
|
|
}
|
|
|
|
Appstream_centerClient::GetResourcePriceOutcome Appstream_centerClient::getResourcePrice(const GetResourcePriceRequest &request) const
|
|
{
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
if (!endpointOutcome.isSuccess())
|
|
return GetResourcePriceOutcome(endpointOutcome.error());
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
if (outcome.isSuccess())
|
|
return GetResourcePriceOutcome(GetResourcePriceResult(outcome.result()));
|
|
else
|
|
return GetResourcePriceOutcome(outcome.error());
|
|
}
|
|
|
|
void Appstream_centerClient::getResourcePriceAsync(const GetResourcePriceRequest& request, const GetResourcePriceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
{
|
|
auto fn = [this, request, handler, context]()
|
|
{
|
|
handler(this, request, getResourcePrice(request), context);
|
|
};
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
}
|
|
|
|
Appstream_centerClient::GetResourcePriceOutcomeCallable Appstream_centerClient::getResourcePriceCallable(const GetResourcePriceRequest &request) const
|
|
{
|
|
auto task = std::make_shared<std::packaged_task<GetResourcePriceOutcome()>>(
|
|
[this, request]()
|
|
{
|
|
return this->getResourcePrice(request);
|
|
});
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
return task->get_future();
|
|
}
|
|
|
|
Appstream_centerClient::GetResourceRenewPriceOutcome Appstream_centerClient::getResourceRenewPrice(const GetResourceRenewPriceRequest &request) const
|
|
{
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
if (!endpointOutcome.isSuccess())
|
|
return GetResourceRenewPriceOutcome(endpointOutcome.error());
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
if (outcome.isSuccess())
|
|
return GetResourceRenewPriceOutcome(GetResourceRenewPriceResult(outcome.result()));
|
|
else
|
|
return GetResourceRenewPriceOutcome(outcome.error());
|
|
}
|
|
|
|
void Appstream_centerClient::getResourceRenewPriceAsync(const GetResourceRenewPriceRequest& request, const GetResourceRenewPriceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
{
|
|
auto fn = [this, request, handler, context]()
|
|
{
|
|
handler(this, request, getResourceRenewPrice(request), context);
|
|
};
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
}
|
|
|
|
Appstream_centerClient::GetResourceRenewPriceOutcomeCallable Appstream_centerClient::getResourceRenewPriceCallable(const GetResourceRenewPriceRequest &request) const
|
|
{
|
|
auto task = std::make_shared<std::packaged_task<GetResourceRenewPriceOutcome()>>(
|
|
[this, request]()
|
|
{
|
|
return this->getResourceRenewPrice(request);
|
|
});
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
return task->get_future();
|
|
}
|
|
|
|
Appstream_centerClient::ListAppInstanceGroupOutcome Appstream_centerClient::listAppInstanceGroup(const ListAppInstanceGroupRequest &request) const
|
|
{
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
if (!endpointOutcome.isSuccess())
|
|
return ListAppInstanceGroupOutcome(endpointOutcome.error());
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
if (outcome.isSuccess())
|
|
return ListAppInstanceGroupOutcome(ListAppInstanceGroupResult(outcome.result()));
|
|
else
|
|
return ListAppInstanceGroupOutcome(outcome.error());
|
|
}
|
|
|
|
void Appstream_centerClient::listAppInstanceGroupAsync(const ListAppInstanceGroupRequest& request, const ListAppInstanceGroupAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
{
|
|
auto fn = [this, request, handler, context]()
|
|
{
|
|
handler(this, request, listAppInstanceGroup(request), context);
|
|
};
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
}
|
|
|
|
Appstream_centerClient::ListAppInstanceGroupOutcomeCallable Appstream_centerClient::listAppInstanceGroupCallable(const ListAppInstanceGroupRequest &request) const
|
|
{
|
|
auto task = std::make_shared<std::packaged_task<ListAppInstanceGroupOutcome()>>(
|
|
[this, request]()
|
|
{
|
|
return this->listAppInstanceGroup(request);
|
|
});
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
return task->get_future();
|
|
}
|
|
|
|
Appstream_centerClient::ListAppInstancesOutcome Appstream_centerClient::listAppInstances(const ListAppInstancesRequest &request) const
|
|
{
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
if (!endpointOutcome.isSuccess())
|
|
return ListAppInstancesOutcome(endpointOutcome.error());
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
if (outcome.isSuccess())
|
|
return ListAppInstancesOutcome(ListAppInstancesResult(outcome.result()));
|
|
else
|
|
return ListAppInstancesOutcome(outcome.error());
|
|
}
|
|
|
|
void Appstream_centerClient::listAppInstancesAsync(const ListAppInstancesRequest& request, const ListAppInstancesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
{
|
|
auto fn = [this, request, handler, context]()
|
|
{
|
|
handler(this, request, listAppInstances(request), context);
|
|
};
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
}
|
|
|
|
Appstream_centerClient::ListAppInstancesOutcomeCallable Appstream_centerClient::listAppInstancesCallable(const ListAppInstancesRequest &request) const
|
|
{
|
|
auto task = std::make_shared<std::packaged_task<ListAppInstancesOutcome()>>(
|
|
[this, request]()
|
|
{
|
|
return this->listAppInstances(request);
|
|
});
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
return task->get_future();
|
|
}
|
|
|
|
Appstream_centerClient::ListNodeInstanceTypeOutcome Appstream_centerClient::listNodeInstanceType(const ListNodeInstanceTypeRequest &request) const
|
|
{
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
if (!endpointOutcome.isSuccess())
|
|
return ListNodeInstanceTypeOutcome(endpointOutcome.error());
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
if (outcome.isSuccess())
|
|
return ListNodeInstanceTypeOutcome(ListNodeInstanceTypeResult(outcome.result()));
|
|
else
|
|
return ListNodeInstanceTypeOutcome(outcome.error());
|
|
}
|
|
|
|
void Appstream_centerClient::listNodeInstanceTypeAsync(const ListNodeInstanceTypeRequest& request, const ListNodeInstanceTypeAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
{
|
|
auto fn = [this, request, handler, context]()
|
|
{
|
|
handler(this, request, listNodeInstanceType(request), context);
|
|
};
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
}
|
|
|
|
Appstream_centerClient::ListNodeInstanceTypeOutcomeCallable Appstream_centerClient::listNodeInstanceTypeCallable(const ListNodeInstanceTypeRequest &request) const
|
|
{
|
|
auto task = std::make_shared<std::packaged_task<ListNodeInstanceTypeOutcome()>>(
|
|
[this, request]()
|
|
{
|
|
return this->listNodeInstanceType(request);
|
|
});
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
return task->get_future();
|
|
}
|
|
|
|
Appstream_centerClient::ListOtaTaskOutcome Appstream_centerClient::listOtaTask(const ListOtaTaskRequest &request) const
|
|
{
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
if (!endpointOutcome.isSuccess())
|
|
return ListOtaTaskOutcome(endpointOutcome.error());
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
if (outcome.isSuccess())
|
|
return ListOtaTaskOutcome(ListOtaTaskResult(outcome.result()));
|
|
else
|
|
return ListOtaTaskOutcome(outcome.error());
|
|
}
|
|
|
|
void Appstream_centerClient::listOtaTaskAsync(const ListOtaTaskRequest& request, const ListOtaTaskAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
{
|
|
auto fn = [this, request, handler, context]()
|
|
{
|
|
handler(this, request, listOtaTask(request), context);
|
|
};
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
}
|
|
|
|
Appstream_centerClient::ListOtaTaskOutcomeCallable Appstream_centerClient::listOtaTaskCallable(const ListOtaTaskRequest &request) const
|
|
{
|
|
auto task = std::make_shared<std::packaged_task<ListOtaTaskOutcome()>>(
|
|
[this, request]()
|
|
{
|
|
return this->listOtaTask(request);
|
|
});
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
return task->get_future();
|
|
}
|
|
|
|
Appstream_centerClient::ListRegionsOutcome Appstream_centerClient::listRegions(const ListRegionsRequest &request) const
|
|
{
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
if (!endpointOutcome.isSuccess())
|
|
return ListRegionsOutcome(endpointOutcome.error());
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
if (outcome.isSuccess())
|
|
return ListRegionsOutcome(ListRegionsResult(outcome.result()));
|
|
else
|
|
return ListRegionsOutcome(outcome.error());
|
|
}
|
|
|
|
void Appstream_centerClient::listRegionsAsync(const ListRegionsRequest& request, const ListRegionsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
{
|
|
auto fn = [this, request, handler, context]()
|
|
{
|
|
handler(this, request, listRegions(request), context);
|
|
};
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
}
|
|
|
|
Appstream_centerClient::ListRegionsOutcomeCallable Appstream_centerClient::listRegionsCallable(const ListRegionsRequest &request) const
|
|
{
|
|
auto task = std::make_shared<std::packaged_task<ListRegionsOutcome()>>(
|
|
[this, request]()
|
|
{
|
|
return this->listRegions(request);
|
|
});
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
return task->get_future();
|
|
}
|
|
|
|
Appstream_centerClient::ListTenantConfigOutcome Appstream_centerClient::listTenantConfig(const ListTenantConfigRequest &request) const
|
|
{
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
if (!endpointOutcome.isSuccess())
|
|
return ListTenantConfigOutcome(endpointOutcome.error());
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
if (outcome.isSuccess())
|
|
return ListTenantConfigOutcome(ListTenantConfigResult(outcome.result()));
|
|
else
|
|
return ListTenantConfigOutcome(outcome.error());
|
|
}
|
|
|
|
void Appstream_centerClient::listTenantConfigAsync(const ListTenantConfigRequest& request, const ListTenantConfigAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
{
|
|
auto fn = [this, request, handler, context]()
|
|
{
|
|
handler(this, request, listTenantConfig(request), context);
|
|
};
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
}
|
|
|
|
Appstream_centerClient::ListTenantConfigOutcomeCallable Appstream_centerClient::listTenantConfigCallable(const ListTenantConfigRequest &request) const
|
|
{
|
|
auto task = std::make_shared<std::packaged_task<ListTenantConfigOutcome()>>(
|
|
[this, request]()
|
|
{
|
|
return this->listTenantConfig(request);
|
|
});
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
return task->get_future();
|
|
}
|
|
|
|
Appstream_centerClient::LogOffAllSessionsInAppInstanceGroupOutcome Appstream_centerClient::logOffAllSessionsInAppInstanceGroup(const LogOffAllSessionsInAppInstanceGroupRequest &request) const
|
|
{
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
if (!endpointOutcome.isSuccess())
|
|
return LogOffAllSessionsInAppInstanceGroupOutcome(endpointOutcome.error());
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
if (outcome.isSuccess())
|
|
return LogOffAllSessionsInAppInstanceGroupOutcome(LogOffAllSessionsInAppInstanceGroupResult(outcome.result()));
|
|
else
|
|
return LogOffAllSessionsInAppInstanceGroupOutcome(outcome.error());
|
|
}
|
|
|
|
void Appstream_centerClient::logOffAllSessionsInAppInstanceGroupAsync(const LogOffAllSessionsInAppInstanceGroupRequest& request, const LogOffAllSessionsInAppInstanceGroupAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
{
|
|
auto fn = [this, request, handler, context]()
|
|
{
|
|
handler(this, request, logOffAllSessionsInAppInstanceGroup(request), context);
|
|
};
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
}
|
|
|
|
Appstream_centerClient::LogOffAllSessionsInAppInstanceGroupOutcomeCallable Appstream_centerClient::logOffAllSessionsInAppInstanceGroupCallable(const LogOffAllSessionsInAppInstanceGroupRequest &request) const
|
|
{
|
|
auto task = std::make_shared<std::packaged_task<LogOffAllSessionsInAppInstanceGroupOutcome()>>(
|
|
[this, request]()
|
|
{
|
|
return this->logOffAllSessionsInAppInstanceGroup(request);
|
|
});
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
return task->get_future();
|
|
}
|
|
|
|
Appstream_centerClient::ModifyAppInstanceGroupAttributeOutcome Appstream_centerClient::modifyAppInstanceGroupAttribute(const ModifyAppInstanceGroupAttributeRequest &request) const
|
|
{
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
if (!endpointOutcome.isSuccess())
|
|
return ModifyAppInstanceGroupAttributeOutcome(endpointOutcome.error());
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
if (outcome.isSuccess())
|
|
return ModifyAppInstanceGroupAttributeOutcome(ModifyAppInstanceGroupAttributeResult(outcome.result()));
|
|
else
|
|
return ModifyAppInstanceGroupAttributeOutcome(outcome.error());
|
|
}
|
|
|
|
void Appstream_centerClient::modifyAppInstanceGroupAttributeAsync(const ModifyAppInstanceGroupAttributeRequest& request, const ModifyAppInstanceGroupAttributeAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
{
|
|
auto fn = [this, request, handler, context]()
|
|
{
|
|
handler(this, request, modifyAppInstanceGroupAttribute(request), context);
|
|
};
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
}
|
|
|
|
Appstream_centerClient::ModifyAppInstanceGroupAttributeOutcomeCallable Appstream_centerClient::modifyAppInstanceGroupAttributeCallable(const ModifyAppInstanceGroupAttributeRequest &request) const
|
|
{
|
|
auto task = std::make_shared<std::packaged_task<ModifyAppInstanceGroupAttributeOutcome()>>(
|
|
[this, request]()
|
|
{
|
|
return this->modifyAppInstanceGroupAttribute(request);
|
|
});
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
return task->get_future();
|
|
}
|
|
|
|
Appstream_centerClient::ModifyNodePoolAttributeOutcome Appstream_centerClient::modifyNodePoolAttribute(const ModifyNodePoolAttributeRequest &request) const
|
|
{
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
if (!endpointOutcome.isSuccess())
|
|
return ModifyNodePoolAttributeOutcome(endpointOutcome.error());
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
if (outcome.isSuccess())
|
|
return ModifyNodePoolAttributeOutcome(ModifyNodePoolAttributeResult(outcome.result()));
|
|
else
|
|
return ModifyNodePoolAttributeOutcome(outcome.error());
|
|
}
|
|
|
|
void Appstream_centerClient::modifyNodePoolAttributeAsync(const ModifyNodePoolAttributeRequest& request, const ModifyNodePoolAttributeAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
{
|
|
auto fn = [this, request, handler, context]()
|
|
{
|
|
handler(this, request, modifyNodePoolAttribute(request), context);
|
|
};
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
}
|
|
|
|
Appstream_centerClient::ModifyNodePoolAttributeOutcomeCallable Appstream_centerClient::modifyNodePoolAttributeCallable(const ModifyNodePoolAttributeRequest &request) const
|
|
{
|
|
auto task = std::make_shared<std::packaged_task<ModifyNodePoolAttributeOutcome()>>(
|
|
[this, request]()
|
|
{
|
|
return this->modifyNodePoolAttribute(request);
|
|
});
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
return task->get_future();
|
|
}
|
|
|
|
Appstream_centerClient::ModifyTenantConfigOutcome Appstream_centerClient::modifyTenantConfig(const ModifyTenantConfigRequest &request) const
|
|
{
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
if (!endpointOutcome.isSuccess())
|
|
return ModifyTenantConfigOutcome(endpointOutcome.error());
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
if (outcome.isSuccess())
|
|
return ModifyTenantConfigOutcome(ModifyTenantConfigResult(outcome.result()));
|
|
else
|
|
return ModifyTenantConfigOutcome(outcome.error());
|
|
}
|
|
|
|
void Appstream_centerClient::modifyTenantConfigAsync(const ModifyTenantConfigRequest& request, const ModifyTenantConfigAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
{
|
|
auto fn = [this, request, handler, context]()
|
|
{
|
|
handler(this, request, modifyTenantConfig(request), context);
|
|
};
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
}
|
|
|
|
Appstream_centerClient::ModifyTenantConfigOutcomeCallable Appstream_centerClient::modifyTenantConfigCallable(const ModifyTenantConfigRequest &request) const
|
|
{
|
|
auto task = std::make_shared<std::packaged_task<ModifyTenantConfigOutcome()>>(
|
|
[this, request]()
|
|
{
|
|
return this->modifyTenantConfig(request);
|
|
});
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
return task->get_future();
|
|
}
|
|
|
|
Appstream_centerClient::PageListAppInstanceGroupUserOutcome Appstream_centerClient::pageListAppInstanceGroupUser(const PageListAppInstanceGroupUserRequest &request) const
|
|
{
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
if (!endpointOutcome.isSuccess())
|
|
return PageListAppInstanceGroupUserOutcome(endpointOutcome.error());
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
if (outcome.isSuccess())
|
|
return PageListAppInstanceGroupUserOutcome(PageListAppInstanceGroupUserResult(outcome.result()));
|
|
else
|
|
return PageListAppInstanceGroupUserOutcome(outcome.error());
|
|
}
|
|
|
|
void Appstream_centerClient::pageListAppInstanceGroupUserAsync(const PageListAppInstanceGroupUserRequest& request, const PageListAppInstanceGroupUserAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
{
|
|
auto fn = [this, request, handler, context]()
|
|
{
|
|
handler(this, request, pageListAppInstanceGroupUser(request), context);
|
|
};
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
}
|
|
|
|
Appstream_centerClient::PageListAppInstanceGroupUserOutcomeCallable Appstream_centerClient::pageListAppInstanceGroupUserCallable(const PageListAppInstanceGroupUserRequest &request) const
|
|
{
|
|
auto task = std::make_shared<std::packaged_task<PageListAppInstanceGroupUserOutcome()>>(
|
|
[this, request]()
|
|
{
|
|
return this->pageListAppInstanceGroupUser(request);
|
|
});
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
return task->get_future();
|
|
}
|
|
|
|
Appstream_centerClient::RenewAppInstanceGroupOutcome Appstream_centerClient::renewAppInstanceGroup(const RenewAppInstanceGroupRequest &request) const
|
|
{
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
if (!endpointOutcome.isSuccess())
|
|
return RenewAppInstanceGroupOutcome(endpointOutcome.error());
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
if (outcome.isSuccess())
|
|
return RenewAppInstanceGroupOutcome(RenewAppInstanceGroupResult(outcome.result()));
|
|
else
|
|
return RenewAppInstanceGroupOutcome(outcome.error());
|
|
}
|
|
|
|
void Appstream_centerClient::renewAppInstanceGroupAsync(const RenewAppInstanceGroupRequest& request, const RenewAppInstanceGroupAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
{
|
|
auto fn = [this, request, handler, context]()
|
|
{
|
|
handler(this, request, renewAppInstanceGroup(request), context);
|
|
};
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
}
|
|
|
|
Appstream_centerClient::RenewAppInstanceGroupOutcomeCallable Appstream_centerClient::renewAppInstanceGroupCallable(const RenewAppInstanceGroupRequest &request) const
|
|
{
|
|
auto task = std::make_shared<std::packaged_task<RenewAppInstanceGroupOutcome()>>(
|
|
[this, request]()
|
|
{
|
|
return this->renewAppInstanceGroup(request);
|
|
});
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
return task->get_future();
|
|
}
|
|
|
|
Appstream_centerClient::UnbindOutcome Appstream_centerClient::unbind(const UnbindRequest &request) const
|
|
{
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
if (!endpointOutcome.isSuccess())
|
|
return UnbindOutcome(endpointOutcome.error());
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
if (outcome.isSuccess())
|
|
return UnbindOutcome(UnbindResult(outcome.result()));
|
|
else
|
|
return UnbindOutcome(outcome.error());
|
|
}
|
|
|
|
void Appstream_centerClient::unbindAsync(const UnbindRequest& request, const UnbindAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
{
|
|
auto fn = [this, request, handler, context]()
|
|
{
|
|
handler(this, request, unbind(request), context);
|
|
};
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
}
|
|
|
|
Appstream_centerClient::UnbindOutcomeCallable Appstream_centerClient::unbindCallable(const UnbindRequest &request) const
|
|
{
|
|
auto task = std::make_shared<std::packaged_task<UnbindOutcome()>>(
|
|
[this, request]()
|
|
{
|
|
return this->unbind(request);
|
|
});
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
return task->get_future();
|
|
}
|
|
|
|
Appstream_centerClient::UpdateAppInstanceGroupImageOutcome Appstream_centerClient::updateAppInstanceGroupImage(const UpdateAppInstanceGroupImageRequest &request) const
|
|
{
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
if (!endpointOutcome.isSuccess())
|
|
return UpdateAppInstanceGroupImageOutcome(endpointOutcome.error());
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
if (outcome.isSuccess())
|
|
return UpdateAppInstanceGroupImageOutcome(UpdateAppInstanceGroupImageResult(outcome.result()));
|
|
else
|
|
return UpdateAppInstanceGroupImageOutcome(outcome.error());
|
|
}
|
|
|
|
void Appstream_centerClient::updateAppInstanceGroupImageAsync(const UpdateAppInstanceGroupImageRequest& request, const UpdateAppInstanceGroupImageAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
{
|
|
auto fn = [this, request, handler, context]()
|
|
{
|
|
handler(this, request, updateAppInstanceGroupImage(request), context);
|
|
};
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
}
|
|
|
|
Appstream_centerClient::UpdateAppInstanceGroupImageOutcomeCallable Appstream_centerClient::updateAppInstanceGroupImageCallable(const UpdateAppInstanceGroupImageRequest &request) const
|
|
{
|
|
auto task = std::make_shared<std::packaged_task<UpdateAppInstanceGroupImageOutcome()>>(
|
|
[this, request]()
|
|
{
|
|
return this->updateAppInstanceGroupImage(request);
|
|
});
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
return task->get_future();
|
|
}
|
|
|