1134 lines
41 KiB
C++
1134 lines
41 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/servicemesh/ServicemeshClient.h>
|
|
#include <alibabacloud/core/SimpleCredentialsProvider.h>
|
|
|
|
using namespace AlibabaCloud;
|
|
using namespace AlibabaCloud::Location;
|
|
using namespace AlibabaCloud::Servicemesh;
|
|
using namespace AlibabaCloud::Servicemesh::Model;
|
|
|
|
namespace
|
|
{
|
|
const std::string SERVICE_NAME = "servicemesh";
|
|
}
|
|
|
|
ServicemeshClient::ServicemeshClient(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, "servicemesh");
|
|
}
|
|
|
|
ServicemeshClient::ServicemeshClient(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, "servicemesh");
|
|
}
|
|
|
|
ServicemeshClient::ServicemeshClient(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, "servicemesh");
|
|
}
|
|
|
|
ServicemeshClient::~ServicemeshClient()
|
|
{}
|
|
|
|
ServicemeshClient::AddClusterIntoServiceMeshOutcome ServicemeshClient::addClusterIntoServiceMesh(const AddClusterIntoServiceMeshRequest &request) const
|
|
{
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
if (!endpointOutcome.isSuccess())
|
|
return AddClusterIntoServiceMeshOutcome(endpointOutcome.error());
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
if (outcome.isSuccess())
|
|
return AddClusterIntoServiceMeshOutcome(AddClusterIntoServiceMeshResult(outcome.result()));
|
|
else
|
|
return AddClusterIntoServiceMeshOutcome(outcome.error());
|
|
}
|
|
|
|
void ServicemeshClient::addClusterIntoServiceMeshAsync(const AddClusterIntoServiceMeshRequest& request, const AddClusterIntoServiceMeshAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
{
|
|
auto fn = [this, request, handler, context]()
|
|
{
|
|
handler(this, request, addClusterIntoServiceMesh(request), context);
|
|
};
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
}
|
|
|
|
ServicemeshClient::AddClusterIntoServiceMeshOutcomeCallable ServicemeshClient::addClusterIntoServiceMeshCallable(const AddClusterIntoServiceMeshRequest &request) const
|
|
{
|
|
auto task = std::make_shared<std::packaged_task<AddClusterIntoServiceMeshOutcome()>>(
|
|
[this, request]()
|
|
{
|
|
return this->addClusterIntoServiceMesh(request);
|
|
});
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
return task->get_future();
|
|
}
|
|
|
|
ServicemeshClient::AddVmAppToMeshOutcome ServicemeshClient::addVmAppToMesh(const AddVmAppToMeshRequest &request) const
|
|
{
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
if (!endpointOutcome.isSuccess())
|
|
return AddVmAppToMeshOutcome(endpointOutcome.error());
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
if (outcome.isSuccess())
|
|
return AddVmAppToMeshOutcome(AddVmAppToMeshResult(outcome.result()));
|
|
else
|
|
return AddVmAppToMeshOutcome(outcome.error());
|
|
}
|
|
|
|
void ServicemeshClient::addVmAppToMeshAsync(const AddVmAppToMeshRequest& request, const AddVmAppToMeshAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
{
|
|
auto fn = [this, request, handler, context]()
|
|
{
|
|
handler(this, request, addVmAppToMesh(request), context);
|
|
};
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
}
|
|
|
|
ServicemeshClient::AddVmAppToMeshOutcomeCallable ServicemeshClient::addVmAppToMeshCallable(const AddVmAppToMeshRequest &request) const
|
|
{
|
|
auto task = std::make_shared<std::packaged_task<AddVmAppToMeshOutcome()>>(
|
|
[this, request]()
|
|
{
|
|
return this->addVmAppToMesh(request);
|
|
});
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
return task->get_future();
|
|
}
|
|
|
|
ServicemeshClient::CreateServiceMeshOutcome ServicemeshClient::createServiceMesh(const CreateServiceMeshRequest &request) const
|
|
{
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
if (!endpointOutcome.isSuccess())
|
|
return CreateServiceMeshOutcome(endpointOutcome.error());
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
if (outcome.isSuccess())
|
|
return CreateServiceMeshOutcome(CreateServiceMeshResult(outcome.result()));
|
|
else
|
|
return CreateServiceMeshOutcome(outcome.error());
|
|
}
|
|
|
|
void ServicemeshClient::createServiceMeshAsync(const CreateServiceMeshRequest& request, const CreateServiceMeshAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
{
|
|
auto fn = [this, request, handler, context]()
|
|
{
|
|
handler(this, request, createServiceMesh(request), context);
|
|
};
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
}
|
|
|
|
ServicemeshClient::CreateServiceMeshOutcomeCallable ServicemeshClient::createServiceMeshCallable(const CreateServiceMeshRequest &request) const
|
|
{
|
|
auto task = std::make_shared<std::packaged_task<CreateServiceMeshOutcome()>>(
|
|
[this, request]()
|
|
{
|
|
return this->createServiceMesh(request);
|
|
});
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
return task->get_future();
|
|
}
|
|
|
|
ServicemeshClient::DeleteServiceMeshOutcome ServicemeshClient::deleteServiceMesh(const DeleteServiceMeshRequest &request) const
|
|
{
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
if (!endpointOutcome.isSuccess())
|
|
return DeleteServiceMeshOutcome(endpointOutcome.error());
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
if (outcome.isSuccess())
|
|
return DeleteServiceMeshOutcome(DeleteServiceMeshResult(outcome.result()));
|
|
else
|
|
return DeleteServiceMeshOutcome(outcome.error());
|
|
}
|
|
|
|
void ServicemeshClient::deleteServiceMeshAsync(const DeleteServiceMeshRequest& request, const DeleteServiceMeshAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
{
|
|
auto fn = [this, request, handler, context]()
|
|
{
|
|
handler(this, request, deleteServiceMesh(request), context);
|
|
};
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
}
|
|
|
|
ServicemeshClient::DeleteServiceMeshOutcomeCallable ServicemeshClient::deleteServiceMeshCallable(const DeleteServiceMeshRequest &request) const
|
|
{
|
|
auto task = std::make_shared<std::packaged_task<DeleteServiceMeshOutcome()>>(
|
|
[this, request]()
|
|
{
|
|
return this->deleteServiceMesh(request);
|
|
});
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
return task->get_future();
|
|
}
|
|
|
|
ServicemeshClient::DescribeCensOutcome ServicemeshClient::describeCens(const DescribeCensRequest &request) const
|
|
{
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
if (!endpointOutcome.isSuccess())
|
|
return DescribeCensOutcome(endpointOutcome.error());
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
if (outcome.isSuccess())
|
|
return DescribeCensOutcome(DescribeCensResult(outcome.result()));
|
|
else
|
|
return DescribeCensOutcome(outcome.error());
|
|
}
|
|
|
|
void ServicemeshClient::describeCensAsync(const DescribeCensRequest& request, const DescribeCensAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
{
|
|
auto fn = [this, request, handler, context]()
|
|
{
|
|
handler(this, request, describeCens(request), context);
|
|
};
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
}
|
|
|
|
ServicemeshClient::DescribeCensOutcomeCallable ServicemeshClient::describeCensCallable(const DescribeCensRequest &request) const
|
|
{
|
|
auto task = std::make_shared<std::packaged_task<DescribeCensOutcome()>>(
|
|
[this, request]()
|
|
{
|
|
return this->describeCens(request);
|
|
});
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
return task->get_future();
|
|
}
|
|
|
|
ServicemeshClient::DescribeClusterGrafanaOutcome ServicemeshClient::describeClusterGrafana(const DescribeClusterGrafanaRequest &request) const
|
|
{
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
if (!endpointOutcome.isSuccess())
|
|
return DescribeClusterGrafanaOutcome(endpointOutcome.error());
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
if (outcome.isSuccess())
|
|
return DescribeClusterGrafanaOutcome(DescribeClusterGrafanaResult(outcome.result()));
|
|
else
|
|
return DescribeClusterGrafanaOutcome(outcome.error());
|
|
}
|
|
|
|
void ServicemeshClient::describeClusterGrafanaAsync(const DescribeClusterGrafanaRequest& request, const DescribeClusterGrafanaAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
{
|
|
auto fn = [this, request, handler, context]()
|
|
{
|
|
handler(this, request, describeClusterGrafana(request), context);
|
|
};
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
}
|
|
|
|
ServicemeshClient::DescribeClusterGrafanaOutcomeCallable ServicemeshClient::describeClusterGrafanaCallable(const DescribeClusterGrafanaRequest &request) const
|
|
{
|
|
auto task = std::make_shared<std::packaged_task<DescribeClusterGrafanaOutcome()>>(
|
|
[this, request]()
|
|
{
|
|
return this->describeClusterGrafana(request);
|
|
});
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
return task->get_future();
|
|
}
|
|
|
|
ServicemeshClient::DescribeClusterPrometheusOutcome ServicemeshClient::describeClusterPrometheus(const DescribeClusterPrometheusRequest &request) const
|
|
{
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
if (!endpointOutcome.isSuccess())
|
|
return DescribeClusterPrometheusOutcome(endpointOutcome.error());
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
if (outcome.isSuccess())
|
|
return DescribeClusterPrometheusOutcome(DescribeClusterPrometheusResult(outcome.result()));
|
|
else
|
|
return DescribeClusterPrometheusOutcome(outcome.error());
|
|
}
|
|
|
|
void ServicemeshClient::describeClusterPrometheusAsync(const DescribeClusterPrometheusRequest& request, const DescribeClusterPrometheusAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
{
|
|
auto fn = [this, request, handler, context]()
|
|
{
|
|
handler(this, request, describeClusterPrometheus(request), context);
|
|
};
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
}
|
|
|
|
ServicemeshClient::DescribeClusterPrometheusOutcomeCallable ServicemeshClient::describeClusterPrometheusCallable(const DescribeClusterPrometheusRequest &request) const
|
|
{
|
|
auto task = std::make_shared<std::packaged_task<DescribeClusterPrometheusOutcome()>>(
|
|
[this, request]()
|
|
{
|
|
return this->describeClusterPrometheus(request);
|
|
});
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
return task->get_future();
|
|
}
|
|
|
|
ServicemeshClient::DescribeClustersInServiceMeshOutcome ServicemeshClient::describeClustersInServiceMesh(const DescribeClustersInServiceMeshRequest &request) const
|
|
{
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
if (!endpointOutcome.isSuccess())
|
|
return DescribeClustersInServiceMeshOutcome(endpointOutcome.error());
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
if (outcome.isSuccess())
|
|
return DescribeClustersInServiceMeshOutcome(DescribeClustersInServiceMeshResult(outcome.result()));
|
|
else
|
|
return DescribeClustersInServiceMeshOutcome(outcome.error());
|
|
}
|
|
|
|
void ServicemeshClient::describeClustersInServiceMeshAsync(const DescribeClustersInServiceMeshRequest& request, const DescribeClustersInServiceMeshAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
{
|
|
auto fn = [this, request, handler, context]()
|
|
{
|
|
handler(this, request, describeClustersInServiceMesh(request), context);
|
|
};
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
}
|
|
|
|
ServicemeshClient::DescribeClustersInServiceMeshOutcomeCallable ServicemeshClient::describeClustersInServiceMeshCallable(const DescribeClustersInServiceMeshRequest &request) const
|
|
{
|
|
auto task = std::make_shared<std::packaged_task<DescribeClustersInServiceMeshOutcome()>>(
|
|
[this, request]()
|
|
{
|
|
return this->describeClustersInServiceMesh(request);
|
|
});
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
return task->get_future();
|
|
}
|
|
|
|
ServicemeshClient::DescribeGuestClusterAccessLogDashboardsOutcome ServicemeshClient::describeGuestClusterAccessLogDashboards(const DescribeGuestClusterAccessLogDashboardsRequest &request) const
|
|
{
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
if (!endpointOutcome.isSuccess())
|
|
return DescribeGuestClusterAccessLogDashboardsOutcome(endpointOutcome.error());
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
if (outcome.isSuccess())
|
|
return DescribeGuestClusterAccessLogDashboardsOutcome(DescribeGuestClusterAccessLogDashboardsResult(outcome.result()));
|
|
else
|
|
return DescribeGuestClusterAccessLogDashboardsOutcome(outcome.error());
|
|
}
|
|
|
|
void ServicemeshClient::describeGuestClusterAccessLogDashboardsAsync(const DescribeGuestClusterAccessLogDashboardsRequest& request, const DescribeGuestClusterAccessLogDashboardsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
{
|
|
auto fn = [this, request, handler, context]()
|
|
{
|
|
handler(this, request, describeGuestClusterAccessLogDashboards(request), context);
|
|
};
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
}
|
|
|
|
ServicemeshClient::DescribeGuestClusterAccessLogDashboardsOutcomeCallable ServicemeshClient::describeGuestClusterAccessLogDashboardsCallable(const DescribeGuestClusterAccessLogDashboardsRequest &request) const
|
|
{
|
|
auto task = std::make_shared<std::packaged_task<DescribeGuestClusterAccessLogDashboardsOutcome()>>(
|
|
[this, request]()
|
|
{
|
|
return this->describeGuestClusterAccessLogDashboards(request);
|
|
});
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
return task->get_future();
|
|
}
|
|
|
|
ServicemeshClient::DescribeIngressGatewaysOutcome ServicemeshClient::describeIngressGateways(const DescribeIngressGatewaysRequest &request) const
|
|
{
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
if (!endpointOutcome.isSuccess())
|
|
return DescribeIngressGatewaysOutcome(endpointOutcome.error());
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
if (outcome.isSuccess())
|
|
return DescribeIngressGatewaysOutcome(DescribeIngressGatewaysResult(outcome.result()));
|
|
else
|
|
return DescribeIngressGatewaysOutcome(outcome.error());
|
|
}
|
|
|
|
void ServicemeshClient::describeIngressGatewaysAsync(const DescribeIngressGatewaysRequest& request, const DescribeIngressGatewaysAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
{
|
|
auto fn = [this, request, handler, context]()
|
|
{
|
|
handler(this, request, describeIngressGateways(request), context);
|
|
};
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
}
|
|
|
|
ServicemeshClient::DescribeIngressGatewaysOutcomeCallable ServicemeshClient::describeIngressGatewaysCallable(const DescribeIngressGatewaysRequest &request) const
|
|
{
|
|
auto task = std::make_shared<std::packaged_task<DescribeIngressGatewaysOutcome()>>(
|
|
[this, request]()
|
|
{
|
|
return this->describeIngressGateways(request);
|
|
});
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
return task->get_future();
|
|
}
|
|
|
|
ServicemeshClient::DescribeServiceMeshDetailOutcome ServicemeshClient::describeServiceMeshDetail(const DescribeServiceMeshDetailRequest &request) const
|
|
{
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
if (!endpointOutcome.isSuccess())
|
|
return DescribeServiceMeshDetailOutcome(endpointOutcome.error());
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
if (outcome.isSuccess())
|
|
return DescribeServiceMeshDetailOutcome(DescribeServiceMeshDetailResult(outcome.result()));
|
|
else
|
|
return DescribeServiceMeshDetailOutcome(outcome.error());
|
|
}
|
|
|
|
void ServicemeshClient::describeServiceMeshDetailAsync(const DescribeServiceMeshDetailRequest& request, const DescribeServiceMeshDetailAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
{
|
|
auto fn = [this, request, handler, context]()
|
|
{
|
|
handler(this, request, describeServiceMeshDetail(request), context);
|
|
};
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
}
|
|
|
|
ServicemeshClient::DescribeServiceMeshDetailOutcomeCallable ServicemeshClient::describeServiceMeshDetailCallable(const DescribeServiceMeshDetailRequest &request) const
|
|
{
|
|
auto task = std::make_shared<std::packaged_task<DescribeServiceMeshDetailOutcome()>>(
|
|
[this, request]()
|
|
{
|
|
return this->describeServiceMeshDetail(request);
|
|
});
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
return task->get_future();
|
|
}
|
|
|
|
ServicemeshClient::DescribeServiceMeshKubeconfigOutcome ServicemeshClient::describeServiceMeshKubeconfig(const DescribeServiceMeshKubeconfigRequest &request) const
|
|
{
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
if (!endpointOutcome.isSuccess())
|
|
return DescribeServiceMeshKubeconfigOutcome(endpointOutcome.error());
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
if (outcome.isSuccess())
|
|
return DescribeServiceMeshKubeconfigOutcome(DescribeServiceMeshKubeconfigResult(outcome.result()));
|
|
else
|
|
return DescribeServiceMeshKubeconfigOutcome(outcome.error());
|
|
}
|
|
|
|
void ServicemeshClient::describeServiceMeshKubeconfigAsync(const DescribeServiceMeshKubeconfigRequest& request, const DescribeServiceMeshKubeconfigAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
{
|
|
auto fn = [this, request, handler, context]()
|
|
{
|
|
handler(this, request, describeServiceMeshKubeconfig(request), context);
|
|
};
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
}
|
|
|
|
ServicemeshClient::DescribeServiceMeshKubeconfigOutcomeCallable ServicemeshClient::describeServiceMeshKubeconfigCallable(const DescribeServiceMeshKubeconfigRequest &request) const
|
|
{
|
|
auto task = std::make_shared<std::packaged_task<DescribeServiceMeshKubeconfigOutcome()>>(
|
|
[this, request]()
|
|
{
|
|
return this->describeServiceMeshKubeconfig(request);
|
|
});
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
return task->get_future();
|
|
}
|
|
|
|
ServicemeshClient::DescribeServiceMeshesOutcome ServicemeshClient::describeServiceMeshes(const DescribeServiceMeshesRequest &request) const
|
|
{
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
if (!endpointOutcome.isSuccess())
|
|
return DescribeServiceMeshesOutcome(endpointOutcome.error());
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
if (outcome.isSuccess())
|
|
return DescribeServiceMeshesOutcome(DescribeServiceMeshesResult(outcome.result()));
|
|
else
|
|
return DescribeServiceMeshesOutcome(outcome.error());
|
|
}
|
|
|
|
void ServicemeshClient::describeServiceMeshesAsync(const DescribeServiceMeshesRequest& request, const DescribeServiceMeshesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
{
|
|
auto fn = [this, request, handler, context]()
|
|
{
|
|
handler(this, request, describeServiceMeshes(request), context);
|
|
};
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
}
|
|
|
|
ServicemeshClient::DescribeServiceMeshesOutcomeCallable ServicemeshClient::describeServiceMeshesCallable(const DescribeServiceMeshesRequest &request) const
|
|
{
|
|
auto task = std::make_shared<std::packaged_task<DescribeServiceMeshesOutcome()>>(
|
|
[this, request]()
|
|
{
|
|
return this->describeServiceMeshes(request);
|
|
});
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
return task->get_future();
|
|
}
|
|
|
|
ServicemeshClient::DescribeUpgradeVersionOutcome ServicemeshClient::describeUpgradeVersion(const DescribeUpgradeVersionRequest &request) const
|
|
{
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
if (!endpointOutcome.isSuccess())
|
|
return DescribeUpgradeVersionOutcome(endpointOutcome.error());
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
if (outcome.isSuccess())
|
|
return DescribeUpgradeVersionOutcome(DescribeUpgradeVersionResult(outcome.result()));
|
|
else
|
|
return DescribeUpgradeVersionOutcome(outcome.error());
|
|
}
|
|
|
|
void ServicemeshClient::describeUpgradeVersionAsync(const DescribeUpgradeVersionRequest& request, const DescribeUpgradeVersionAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
{
|
|
auto fn = [this, request, handler, context]()
|
|
{
|
|
handler(this, request, describeUpgradeVersion(request), context);
|
|
};
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
}
|
|
|
|
ServicemeshClient::DescribeUpgradeVersionOutcomeCallable ServicemeshClient::describeUpgradeVersionCallable(const DescribeUpgradeVersionRequest &request) const
|
|
{
|
|
auto task = std::make_shared<std::packaged_task<DescribeUpgradeVersionOutcome()>>(
|
|
[this, request]()
|
|
{
|
|
return this->describeUpgradeVersion(request);
|
|
});
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
return task->get_future();
|
|
}
|
|
|
|
ServicemeshClient::GetAutoInjectionLabelSyncStatusOutcome ServicemeshClient::getAutoInjectionLabelSyncStatus(const GetAutoInjectionLabelSyncStatusRequest &request) const
|
|
{
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
if (!endpointOutcome.isSuccess())
|
|
return GetAutoInjectionLabelSyncStatusOutcome(endpointOutcome.error());
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
if (outcome.isSuccess())
|
|
return GetAutoInjectionLabelSyncStatusOutcome(GetAutoInjectionLabelSyncStatusResult(outcome.result()));
|
|
else
|
|
return GetAutoInjectionLabelSyncStatusOutcome(outcome.error());
|
|
}
|
|
|
|
void ServicemeshClient::getAutoInjectionLabelSyncStatusAsync(const GetAutoInjectionLabelSyncStatusRequest& request, const GetAutoInjectionLabelSyncStatusAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
{
|
|
auto fn = [this, request, handler, context]()
|
|
{
|
|
handler(this, request, getAutoInjectionLabelSyncStatus(request), context);
|
|
};
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
}
|
|
|
|
ServicemeshClient::GetAutoInjectionLabelSyncStatusOutcomeCallable ServicemeshClient::getAutoInjectionLabelSyncStatusCallable(const GetAutoInjectionLabelSyncStatusRequest &request) const
|
|
{
|
|
auto task = std::make_shared<std::packaged_task<GetAutoInjectionLabelSyncStatusOutcome()>>(
|
|
[this, request]()
|
|
{
|
|
return this->getAutoInjectionLabelSyncStatus(request);
|
|
});
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
return task->get_future();
|
|
}
|
|
|
|
ServicemeshClient::GetDiagnosisOutcome ServicemeshClient::getDiagnosis(const GetDiagnosisRequest &request) const
|
|
{
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
if (!endpointOutcome.isSuccess())
|
|
return GetDiagnosisOutcome(endpointOutcome.error());
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
if (outcome.isSuccess())
|
|
return GetDiagnosisOutcome(GetDiagnosisResult(outcome.result()));
|
|
else
|
|
return GetDiagnosisOutcome(outcome.error());
|
|
}
|
|
|
|
void ServicemeshClient::getDiagnosisAsync(const GetDiagnosisRequest& request, const GetDiagnosisAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
{
|
|
auto fn = [this, request, handler, context]()
|
|
{
|
|
handler(this, request, getDiagnosis(request), context);
|
|
};
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
}
|
|
|
|
ServicemeshClient::GetDiagnosisOutcomeCallable ServicemeshClient::getDiagnosisCallable(const GetDiagnosisRequest &request) const
|
|
{
|
|
auto task = std::make_shared<std::packaged_task<GetDiagnosisOutcome()>>(
|
|
[this, request]()
|
|
{
|
|
return this->getDiagnosis(request);
|
|
});
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
return task->get_future();
|
|
}
|
|
|
|
ServicemeshClient::GetRegisteredServiceEndpointsOutcome ServicemeshClient::getRegisteredServiceEndpoints(const GetRegisteredServiceEndpointsRequest &request) const
|
|
{
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
if (!endpointOutcome.isSuccess())
|
|
return GetRegisteredServiceEndpointsOutcome(endpointOutcome.error());
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
if (outcome.isSuccess())
|
|
return GetRegisteredServiceEndpointsOutcome(GetRegisteredServiceEndpointsResult(outcome.result()));
|
|
else
|
|
return GetRegisteredServiceEndpointsOutcome(outcome.error());
|
|
}
|
|
|
|
void ServicemeshClient::getRegisteredServiceEndpointsAsync(const GetRegisteredServiceEndpointsRequest& request, const GetRegisteredServiceEndpointsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
{
|
|
auto fn = [this, request, handler, context]()
|
|
{
|
|
handler(this, request, getRegisteredServiceEndpoints(request), context);
|
|
};
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
}
|
|
|
|
ServicemeshClient::GetRegisteredServiceEndpointsOutcomeCallable ServicemeshClient::getRegisteredServiceEndpointsCallable(const GetRegisteredServiceEndpointsRequest &request) const
|
|
{
|
|
auto task = std::make_shared<std::packaged_task<GetRegisteredServiceEndpointsOutcome()>>(
|
|
[this, request]()
|
|
{
|
|
return this->getRegisteredServiceEndpoints(request);
|
|
});
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
return task->get_future();
|
|
}
|
|
|
|
ServicemeshClient::GetRegisteredServiceNamespacesOutcome ServicemeshClient::getRegisteredServiceNamespaces(const GetRegisteredServiceNamespacesRequest &request) const
|
|
{
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
if (!endpointOutcome.isSuccess())
|
|
return GetRegisteredServiceNamespacesOutcome(endpointOutcome.error());
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
if (outcome.isSuccess())
|
|
return GetRegisteredServiceNamespacesOutcome(GetRegisteredServiceNamespacesResult(outcome.result()));
|
|
else
|
|
return GetRegisteredServiceNamespacesOutcome(outcome.error());
|
|
}
|
|
|
|
void ServicemeshClient::getRegisteredServiceNamespacesAsync(const GetRegisteredServiceNamespacesRequest& request, const GetRegisteredServiceNamespacesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
{
|
|
auto fn = [this, request, handler, context]()
|
|
{
|
|
handler(this, request, getRegisteredServiceNamespaces(request), context);
|
|
};
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
}
|
|
|
|
ServicemeshClient::GetRegisteredServiceNamespacesOutcomeCallable ServicemeshClient::getRegisteredServiceNamespacesCallable(const GetRegisteredServiceNamespacesRequest &request) const
|
|
{
|
|
auto task = std::make_shared<std::packaged_task<GetRegisteredServiceNamespacesOutcome()>>(
|
|
[this, request]()
|
|
{
|
|
return this->getRegisteredServiceNamespaces(request);
|
|
});
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
return task->get_future();
|
|
}
|
|
|
|
ServicemeshClient::GetRegisteredServicesOutcome ServicemeshClient::getRegisteredServices(const GetRegisteredServicesRequest &request) const
|
|
{
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
if (!endpointOutcome.isSuccess())
|
|
return GetRegisteredServicesOutcome(endpointOutcome.error());
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
if (outcome.isSuccess())
|
|
return GetRegisteredServicesOutcome(GetRegisteredServicesResult(outcome.result()));
|
|
else
|
|
return GetRegisteredServicesOutcome(outcome.error());
|
|
}
|
|
|
|
void ServicemeshClient::getRegisteredServicesAsync(const GetRegisteredServicesRequest& request, const GetRegisteredServicesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
{
|
|
auto fn = [this, request, handler, context]()
|
|
{
|
|
handler(this, request, getRegisteredServices(request), context);
|
|
};
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
}
|
|
|
|
ServicemeshClient::GetRegisteredServicesOutcomeCallable ServicemeshClient::getRegisteredServicesCallable(const GetRegisteredServicesRequest &request) const
|
|
{
|
|
auto task = std::make_shared<std::packaged_task<GetRegisteredServicesOutcome()>>(
|
|
[this, request]()
|
|
{
|
|
return this->getRegisteredServices(request);
|
|
});
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
return task->get_future();
|
|
}
|
|
|
|
ServicemeshClient::GetServiceMeshSlbOutcome ServicemeshClient::getServiceMeshSlb(const GetServiceMeshSlbRequest &request) const
|
|
{
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
if (!endpointOutcome.isSuccess())
|
|
return GetServiceMeshSlbOutcome(endpointOutcome.error());
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
if (outcome.isSuccess())
|
|
return GetServiceMeshSlbOutcome(GetServiceMeshSlbResult(outcome.result()));
|
|
else
|
|
return GetServiceMeshSlbOutcome(outcome.error());
|
|
}
|
|
|
|
void ServicemeshClient::getServiceMeshSlbAsync(const GetServiceMeshSlbRequest& request, const GetServiceMeshSlbAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
{
|
|
auto fn = [this, request, handler, context]()
|
|
{
|
|
handler(this, request, getServiceMeshSlb(request), context);
|
|
};
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
}
|
|
|
|
ServicemeshClient::GetServiceMeshSlbOutcomeCallable ServicemeshClient::getServiceMeshSlbCallable(const GetServiceMeshSlbRequest &request) const
|
|
{
|
|
auto task = std::make_shared<std::packaged_task<GetServiceMeshSlbOutcome()>>(
|
|
[this, request]()
|
|
{
|
|
return this->getServiceMeshSlb(request);
|
|
});
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
return task->get_future();
|
|
}
|
|
|
|
ServicemeshClient::GetServiceRegistrySourceOutcome ServicemeshClient::getServiceRegistrySource(const GetServiceRegistrySourceRequest &request) const
|
|
{
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
if (!endpointOutcome.isSuccess())
|
|
return GetServiceRegistrySourceOutcome(endpointOutcome.error());
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
if (outcome.isSuccess())
|
|
return GetServiceRegistrySourceOutcome(GetServiceRegistrySourceResult(outcome.result()));
|
|
else
|
|
return GetServiceRegistrySourceOutcome(outcome.error());
|
|
}
|
|
|
|
void ServicemeshClient::getServiceRegistrySourceAsync(const GetServiceRegistrySourceRequest& request, const GetServiceRegistrySourceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
{
|
|
auto fn = [this, request, handler, context]()
|
|
{
|
|
handler(this, request, getServiceRegistrySource(request), context);
|
|
};
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
}
|
|
|
|
ServicemeshClient::GetServiceRegistrySourceOutcomeCallable ServicemeshClient::getServiceRegistrySourceCallable(const GetServiceRegistrySourceRequest &request) const
|
|
{
|
|
auto task = std::make_shared<std::packaged_task<GetServiceRegistrySourceOutcome()>>(
|
|
[this, request]()
|
|
{
|
|
return this->getServiceRegistrySource(request);
|
|
});
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
return task->get_future();
|
|
}
|
|
|
|
ServicemeshClient::GetVmAppMeshInfoOutcome ServicemeshClient::getVmAppMeshInfo(const GetVmAppMeshInfoRequest &request) const
|
|
{
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
if (!endpointOutcome.isSuccess())
|
|
return GetVmAppMeshInfoOutcome(endpointOutcome.error());
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
if (outcome.isSuccess())
|
|
return GetVmAppMeshInfoOutcome(GetVmAppMeshInfoResult(outcome.result()));
|
|
else
|
|
return GetVmAppMeshInfoOutcome(outcome.error());
|
|
}
|
|
|
|
void ServicemeshClient::getVmAppMeshInfoAsync(const GetVmAppMeshInfoRequest& request, const GetVmAppMeshInfoAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
{
|
|
auto fn = [this, request, handler, context]()
|
|
{
|
|
handler(this, request, getVmAppMeshInfo(request), context);
|
|
};
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
}
|
|
|
|
ServicemeshClient::GetVmAppMeshInfoOutcomeCallable ServicemeshClient::getVmAppMeshInfoCallable(const GetVmAppMeshInfoRequest &request) const
|
|
{
|
|
auto task = std::make_shared<std::packaged_task<GetVmAppMeshInfoOutcome()>>(
|
|
[this, request]()
|
|
{
|
|
return this->getVmAppMeshInfo(request);
|
|
});
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
return task->get_future();
|
|
}
|
|
|
|
ServicemeshClient::GetVmMetaOutcome ServicemeshClient::getVmMeta(const GetVmMetaRequest &request) const
|
|
{
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
if (!endpointOutcome.isSuccess())
|
|
return GetVmMetaOutcome(endpointOutcome.error());
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
if (outcome.isSuccess())
|
|
return GetVmMetaOutcome(GetVmMetaResult(outcome.result()));
|
|
else
|
|
return GetVmMetaOutcome(outcome.error());
|
|
}
|
|
|
|
void ServicemeshClient::getVmMetaAsync(const GetVmMetaRequest& request, const GetVmMetaAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
{
|
|
auto fn = [this, request, handler, context]()
|
|
{
|
|
handler(this, request, getVmMeta(request), context);
|
|
};
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
}
|
|
|
|
ServicemeshClient::GetVmMetaOutcomeCallable ServicemeshClient::getVmMetaCallable(const GetVmMetaRequest &request) const
|
|
{
|
|
auto task = std::make_shared<std::packaged_task<GetVmMetaOutcome()>>(
|
|
[this, request]()
|
|
{
|
|
return this->getVmMeta(request);
|
|
});
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
return task->get_future();
|
|
}
|
|
|
|
ServicemeshClient::RemoveClusterFromServiceMeshOutcome ServicemeshClient::removeClusterFromServiceMesh(const RemoveClusterFromServiceMeshRequest &request) const
|
|
{
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
if (!endpointOutcome.isSuccess())
|
|
return RemoveClusterFromServiceMeshOutcome(endpointOutcome.error());
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
if (outcome.isSuccess())
|
|
return RemoveClusterFromServiceMeshOutcome(RemoveClusterFromServiceMeshResult(outcome.result()));
|
|
else
|
|
return RemoveClusterFromServiceMeshOutcome(outcome.error());
|
|
}
|
|
|
|
void ServicemeshClient::removeClusterFromServiceMeshAsync(const RemoveClusterFromServiceMeshRequest& request, const RemoveClusterFromServiceMeshAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
{
|
|
auto fn = [this, request, handler, context]()
|
|
{
|
|
handler(this, request, removeClusterFromServiceMesh(request), context);
|
|
};
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
}
|
|
|
|
ServicemeshClient::RemoveClusterFromServiceMeshOutcomeCallable ServicemeshClient::removeClusterFromServiceMeshCallable(const RemoveClusterFromServiceMeshRequest &request) const
|
|
{
|
|
auto task = std::make_shared<std::packaged_task<RemoveClusterFromServiceMeshOutcome()>>(
|
|
[this, request]()
|
|
{
|
|
return this->removeClusterFromServiceMesh(request);
|
|
});
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
return task->get_future();
|
|
}
|
|
|
|
ServicemeshClient::RemoveVmAppFromMeshOutcome ServicemeshClient::removeVmAppFromMesh(const RemoveVmAppFromMeshRequest &request) const
|
|
{
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
if (!endpointOutcome.isSuccess())
|
|
return RemoveVmAppFromMeshOutcome(endpointOutcome.error());
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
if (outcome.isSuccess())
|
|
return RemoveVmAppFromMeshOutcome(RemoveVmAppFromMeshResult(outcome.result()));
|
|
else
|
|
return RemoveVmAppFromMeshOutcome(outcome.error());
|
|
}
|
|
|
|
void ServicemeshClient::removeVmAppFromMeshAsync(const RemoveVmAppFromMeshRequest& request, const RemoveVmAppFromMeshAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
{
|
|
auto fn = [this, request, handler, context]()
|
|
{
|
|
handler(this, request, removeVmAppFromMesh(request), context);
|
|
};
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
}
|
|
|
|
ServicemeshClient::RemoveVmAppFromMeshOutcomeCallable ServicemeshClient::removeVmAppFromMeshCallable(const RemoveVmAppFromMeshRequest &request) const
|
|
{
|
|
auto task = std::make_shared<std::packaged_task<RemoveVmAppFromMeshOutcome()>>(
|
|
[this, request]()
|
|
{
|
|
return this->removeVmAppFromMesh(request);
|
|
});
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
return task->get_future();
|
|
}
|
|
|
|
ServicemeshClient::RunDiagnosisOutcome ServicemeshClient::runDiagnosis(const RunDiagnosisRequest &request) const
|
|
{
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
if (!endpointOutcome.isSuccess())
|
|
return RunDiagnosisOutcome(endpointOutcome.error());
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
if (outcome.isSuccess())
|
|
return RunDiagnosisOutcome(RunDiagnosisResult(outcome.result()));
|
|
else
|
|
return RunDiagnosisOutcome(outcome.error());
|
|
}
|
|
|
|
void ServicemeshClient::runDiagnosisAsync(const RunDiagnosisRequest& request, const RunDiagnosisAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
{
|
|
auto fn = [this, request, handler, context]()
|
|
{
|
|
handler(this, request, runDiagnosis(request), context);
|
|
};
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
}
|
|
|
|
ServicemeshClient::RunDiagnosisOutcomeCallable ServicemeshClient::runDiagnosisCallable(const RunDiagnosisRequest &request) const
|
|
{
|
|
auto task = std::make_shared<std::packaged_task<RunDiagnosisOutcome()>>(
|
|
[this, request]()
|
|
{
|
|
return this->runDiagnosis(request);
|
|
});
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
return task->get_future();
|
|
}
|
|
|
|
ServicemeshClient::SetServiceRegistrySourceOutcome ServicemeshClient::setServiceRegistrySource(const SetServiceRegistrySourceRequest &request) const
|
|
{
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
if (!endpointOutcome.isSuccess())
|
|
return SetServiceRegistrySourceOutcome(endpointOutcome.error());
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
if (outcome.isSuccess())
|
|
return SetServiceRegistrySourceOutcome(SetServiceRegistrySourceResult(outcome.result()));
|
|
else
|
|
return SetServiceRegistrySourceOutcome(outcome.error());
|
|
}
|
|
|
|
void ServicemeshClient::setServiceRegistrySourceAsync(const SetServiceRegistrySourceRequest& request, const SetServiceRegistrySourceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
{
|
|
auto fn = [this, request, handler, context]()
|
|
{
|
|
handler(this, request, setServiceRegistrySource(request), context);
|
|
};
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
}
|
|
|
|
ServicemeshClient::SetServiceRegistrySourceOutcomeCallable ServicemeshClient::setServiceRegistrySourceCallable(const SetServiceRegistrySourceRequest &request) const
|
|
{
|
|
auto task = std::make_shared<std::packaged_task<SetServiceRegistrySourceOutcome()>>(
|
|
[this, request]()
|
|
{
|
|
return this->setServiceRegistrySource(request);
|
|
});
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
return task->get_future();
|
|
}
|
|
|
|
ServicemeshClient::UpdateIstioInjectionConfigOutcome ServicemeshClient::updateIstioInjectionConfig(const UpdateIstioInjectionConfigRequest &request) const
|
|
{
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
if (!endpointOutcome.isSuccess())
|
|
return UpdateIstioInjectionConfigOutcome(endpointOutcome.error());
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
if (outcome.isSuccess())
|
|
return UpdateIstioInjectionConfigOutcome(UpdateIstioInjectionConfigResult(outcome.result()));
|
|
else
|
|
return UpdateIstioInjectionConfigOutcome(outcome.error());
|
|
}
|
|
|
|
void ServicemeshClient::updateIstioInjectionConfigAsync(const UpdateIstioInjectionConfigRequest& request, const UpdateIstioInjectionConfigAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
{
|
|
auto fn = [this, request, handler, context]()
|
|
{
|
|
handler(this, request, updateIstioInjectionConfig(request), context);
|
|
};
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
}
|
|
|
|
ServicemeshClient::UpdateIstioInjectionConfigOutcomeCallable ServicemeshClient::updateIstioInjectionConfigCallable(const UpdateIstioInjectionConfigRequest &request) const
|
|
{
|
|
auto task = std::make_shared<std::packaged_task<UpdateIstioInjectionConfigOutcome()>>(
|
|
[this, request]()
|
|
{
|
|
return this->updateIstioInjectionConfig(request);
|
|
});
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
return task->get_future();
|
|
}
|
|
|
|
ServicemeshClient::UpdateMeshFeatureOutcome ServicemeshClient::updateMeshFeature(const UpdateMeshFeatureRequest &request) const
|
|
{
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
if (!endpointOutcome.isSuccess())
|
|
return UpdateMeshFeatureOutcome(endpointOutcome.error());
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
if (outcome.isSuccess())
|
|
return UpdateMeshFeatureOutcome(UpdateMeshFeatureResult(outcome.result()));
|
|
else
|
|
return UpdateMeshFeatureOutcome(outcome.error());
|
|
}
|
|
|
|
void ServicemeshClient::updateMeshFeatureAsync(const UpdateMeshFeatureRequest& request, const UpdateMeshFeatureAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
{
|
|
auto fn = [this, request, handler, context]()
|
|
{
|
|
handler(this, request, updateMeshFeature(request), context);
|
|
};
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
}
|
|
|
|
ServicemeshClient::UpdateMeshFeatureOutcomeCallable ServicemeshClient::updateMeshFeatureCallable(const UpdateMeshFeatureRequest &request) const
|
|
{
|
|
auto task = std::make_shared<std::packaged_task<UpdateMeshFeatureOutcome()>>(
|
|
[this, request]()
|
|
{
|
|
return this->updateMeshFeature(request);
|
|
});
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
return task->get_future();
|
|
}
|
|
|
|
ServicemeshClient::UpgradeMeshVersionOutcome ServicemeshClient::upgradeMeshVersion(const UpgradeMeshVersionRequest &request) const
|
|
{
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
if (!endpointOutcome.isSuccess())
|
|
return UpgradeMeshVersionOutcome(endpointOutcome.error());
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
if (outcome.isSuccess())
|
|
return UpgradeMeshVersionOutcome(UpgradeMeshVersionResult(outcome.result()));
|
|
else
|
|
return UpgradeMeshVersionOutcome(outcome.error());
|
|
}
|
|
|
|
void ServicemeshClient::upgradeMeshVersionAsync(const UpgradeMeshVersionRequest& request, const UpgradeMeshVersionAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
{
|
|
auto fn = [this, request, handler, context]()
|
|
{
|
|
handler(this, request, upgradeMeshVersion(request), context);
|
|
};
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
}
|
|
|
|
ServicemeshClient::UpgradeMeshVersionOutcomeCallable ServicemeshClient::upgradeMeshVersionCallable(const UpgradeMeshVersionRequest &request) const
|
|
{
|
|
auto task = std::make_shared<std::packaged_task<UpgradeMeshVersionOutcome()>>(
|
|
[this, request]()
|
|
{
|
|
return this->upgradeMeshVersion(request);
|
|
});
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
return task->get_future();
|
|
}
|
|
|