1 /**
2 * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
3 * SPDX-License-Identifier: Apache-2.0.
4 */
5
6 #include <aws/core/utils/Outcome.h>
7 #include <aws/core/auth/AWSAuthSigner.h>
8 #include <aws/core/client/CoreErrors.h>
9 #include <aws/core/client/RetryStrategy.h>
10 #include <aws/core/http/HttpClient.h>
11 #include <aws/core/http/HttpResponse.h>
12 #include <aws/core/http/HttpClientFactory.h>
13 #include <aws/core/auth/AWSCredentialsProviderChain.h>
14 #include <aws/core/utils/json/JsonSerializer.h>
15 #include <aws/core/utils/memory/stl/AWSStringStream.h>
16 #include <aws/core/utils/threading/Executor.h>
17 #include <aws/core/utils/DNS.h>
18 #include <aws/core/utils/logging/LogMacros.h>
19
20 #include <aws/es/ElasticsearchServiceClient.h>
21 #include <aws/es/ElasticsearchServiceEndpoint.h>
22 #include <aws/es/ElasticsearchServiceErrorMarshaller.h>
23 #include <aws/es/model/AcceptInboundCrossClusterSearchConnectionRequest.h>
24 #include <aws/es/model/AddTagsRequest.h>
25 #include <aws/es/model/AssociatePackageRequest.h>
26 #include <aws/es/model/CancelElasticsearchServiceSoftwareUpdateRequest.h>
27 #include <aws/es/model/CreateElasticsearchDomainRequest.h>
28 #include <aws/es/model/CreateOutboundCrossClusterSearchConnectionRequest.h>
29 #include <aws/es/model/CreatePackageRequest.h>
30 #include <aws/es/model/DeleteElasticsearchDomainRequest.h>
31 #include <aws/es/model/DeleteInboundCrossClusterSearchConnectionRequest.h>
32 #include <aws/es/model/DeleteOutboundCrossClusterSearchConnectionRequest.h>
33 #include <aws/es/model/DeletePackageRequest.h>
34 #include <aws/es/model/DescribeDomainAutoTunesRequest.h>
35 #include <aws/es/model/DescribeElasticsearchDomainRequest.h>
36 #include <aws/es/model/DescribeElasticsearchDomainConfigRequest.h>
37 #include <aws/es/model/DescribeElasticsearchDomainsRequest.h>
38 #include <aws/es/model/DescribeElasticsearchInstanceTypeLimitsRequest.h>
39 #include <aws/es/model/DescribeInboundCrossClusterSearchConnectionsRequest.h>
40 #include <aws/es/model/DescribeOutboundCrossClusterSearchConnectionsRequest.h>
41 #include <aws/es/model/DescribePackagesRequest.h>
42 #include <aws/es/model/DescribeReservedElasticsearchInstanceOfferingsRequest.h>
43 #include <aws/es/model/DescribeReservedElasticsearchInstancesRequest.h>
44 #include <aws/es/model/DissociatePackageRequest.h>
45 #include <aws/es/model/GetCompatibleElasticsearchVersionsRequest.h>
46 #include <aws/es/model/GetPackageVersionHistoryRequest.h>
47 #include <aws/es/model/GetUpgradeHistoryRequest.h>
48 #include <aws/es/model/GetUpgradeStatusRequest.h>
49 #include <aws/es/model/ListDomainNamesRequest.h>
50 #include <aws/es/model/ListDomainsForPackageRequest.h>
51 #include <aws/es/model/ListElasticsearchInstanceTypesRequest.h>
52 #include <aws/es/model/ListElasticsearchVersionsRequest.h>
53 #include <aws/es/model/ListPackagesForDomainRequest.h>
54 #include <aws/es/model/ListTagsRequest.h>
55 #include <aws/es/model/PurchaseReservedElasticsearchInstanceOfferingRequest.h>
56 #include <aws/es/model/RejectInboundCrossClusterSearchConnectionRequest.h>
57 #include <aws/es/model/RemoveTagsRequest.h>
58 #include <aws/es/model/StartElasticsearchServiceSoftwareUpdateRequest.h>
59 #include <aws/es/model/UpdateElasticsearchDomainConfigRequest.h>
60 #include <aws/es/model/UpdatePackageRequest.h>
61 #include <aws/es/model/UpgradeElasticsearchDomainRequest.h>
62
63 using namespace Aws;
64 using namespace Aws::Auth;
65 using namespace Aws::Client;
66 using namespace Aws::ElasticsearchService;
67 using namespace Aws::ElasticsearchService::Model;
68 using namespace Aws::Http;
69 using namespace Aws::Utils::Json;
70
71 static const char* SERVICE_NAME = "es";
72 static const char* ALLOCATION_TAG = "ElasticsearchServiceClient";
73
74
ElasticsearchServiceClient(const Client::ClientConfiguration & clientConfiguration)75 ElasticsearchServiceClient::ElasticsearchServiceClient(const Client::ClientConfiguration& clientConfiguration) :
76 BASECLASS(clientConfiguration,
77 Aws::MakeShared<AWSAuthV4Signer>(ALLOCATION_TAG, Aws::MakeShared<DefaultAWSCredentialsProviderChain>(ALLOCATION_TAG),
78 SERVICE_NAME, Aws::Region::ComputeSignerRegion(clientConfiguration.region)),
79 Aws::MakeShared<ElasticsearchServiceErrorMarshaller>(ALLOCATION_TAG)),
80 m_executor(clientConfiguration.executor)
81 {
82 init(clientConfiguration);
83 }
84
ElasticsearchServiceClient(const AWSCredentials & credentials,const Client::ClientConfiguration & clientConfiguration)85 ElasticsearchServiceClient::ElasticsearchServiceClient(const AWSCredentials& credentials, const Client::ClientConfiguration& clientConfiguration) :
86 BASECLASS(clientConfiguration,
87 Aws::MakeShared<AWSAuthV4Signer>(ALLOCATION_TAG, Aws::MakeShared<SimpleAWSCredentialsProvider>(ALLOCATION_TAG, credentials),
88 SERVICE_NAME, Aws::Region::ComputeSignerRegion(clientConfiguration.region)),
89 Aws::MakeShared<ElasticsearchServiceErrorMarshaller>(ALLOCATION_TAG)),
90 m_executor(clientConfiguration.executor)
91 {
92 init(clientConfiguration);
93 }
94
ElasticsearchServiceClient(const std::shared_ptr<AWSCredentialsProvider> & credentialsProvider,const Client::ClientConfiguration & clientConfiguration)95 ElasticsearchServiceClient::ElasticsearchServiceClient(const std::shared_ptr<AWSCredentialsProvider>& credentialsProvider,
96 const Client::ClientConfiguration& clientConfiguration) :
97 BASECLASS(clientConfiguration,
98 Aws::MakeShared<AWSAuthV4Signer>(ALLOCATION_TAG, credentialsProvider,
99 SERVICE_NAME, Aws::Region::ComputeSignerRegion(clientConfiguration.region)),
100 Aws::MakeShared<ElasticsearchServiceErrorMarshaller>(ALLOCATION_TAG)),
101 m_executor(clientConfiguration.executor)
102 {
103 init(clientConfiguration);
104 }
105
~ElasticsearchServiceClient()106 ElasticsearchServiceClient::~ElasticsearchServiceClient()
107 {
108 }
109
init(const Client::ClientConfiguration & config)110 void ElasticsearchServiceClient::init(const Client::ClientConfiguration& config)
111 {
112 SetServiceClientName("Elasticsearch Service");
113 m_configScheme = SchemeMapper::ToString(config.scheme);
114 if (config.endpointOverride.empty())
115 {
116 m_uri = m_configScheme + "://" + ElasticsearchServiceEndpoint::ForRegion(config.region, config.useDualStack);
117 }
118 else
119 {
120 OverrideEndpoint(config.endpointOverride);
121 }
122 }
123
OverrideEndpoint(const Aws::String & endpoint)124 void ElasticsearchServiceClient::OverrideEndpoint(const Aws::String& endpoint)
125 {
126 if (endpoint.compare(0, 7, "http://") == 0 || endpoint.compare(0, 8, "https://") == 0)
127 {
128 m_uri = endpoint;
129 }
130 else
131 {
132 m_uri = m_configScheme + "://" + endpoint;
133 }
134 }
135
AcceptInboundCrossClusterSearchConnection(const AcceptInboundCrossClusterSearchConnectionRequest & request) const136 AcceptInboundCrossClusterSearchConnectionOutcome ElasticsearchServiceClient::AcceptInboundCrossClusterSearchConnection(const AcceptInboundCrossClusterSearchConnectionRequest& request) const
137 {
138 if (!request.CrossClusterSearchConnectionIdHasBeenSet())
139 {
140 AWS_LOGSTREAM_ERROR("AcceptInboundCrossClusterSearchConnection", "Required field: CrossClusterSearchConnectionId, is not set");
141 return AcceptInboundCrossClusterSearchConnectionOutcome(Aws::Client::AWSError<ElasticsearchServiceErrors>(ElasticsearchServiceErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [CrossClusterSearchConnectionId]", false));
142 }
143 Aws::Http::URI uri = m_uri;
144 uri.AddPathSegments("/2015-01-01/es/ccs/inboundConnection/");
145 uri.AddPathSegment(request.GetCrossClusterSearchConnectionId());
146 uri.AddPathSegments("/accept");
147 return AcceptInboundCrossClusterSearchConnectionOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_PUT, Aws::Auth::SIGV4_SIGNER));
148 }
149
AcceptInboundCrossClusterSearchConnectionCallable(const AcceptInboundCrossClusterSearchConnectionRequest & request) const150 AcceptInboundCrossClusterSearchConnectionOutcomeCallable ElasticsearchServiceClient::AcceptInboundCrossClusterSearchConnectionCallable(const AcceptInboundCrossClusterSearchConnectionRequest& request) const
151 {
152 auto task = Aws::MakeShared< std::packaged_task< AcceptInboundCrossClusterSearchConnectionOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->AcceptInboundCrossClusterSearchConnection(request); } );
153 auto packagedFunction = [task]() { (*task)(); };
154 m_executor->Submit(packagedFunction);
155 return task->get_future();
156 }
157
AcceptInboundCrossClusterSearchConnectionAsync(const AcceptInboundCrossClusterSearchConnectionRequest & request,const AcceptInboundCrossClusterSearchConnectionResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const158 void ElasticsearchServiceClient::AcceptInboundCrossClusterSearchConnectionAsync(const AcceptInboundCrossClusterSearchConnectionRequest& request, const AcceptInboundCrossClusterSearchConnectionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
159 {
160 m_executor->Submit( [this, request, handler, context](){ this->AcceptInboundCrossClusterSearchConnectionAsyncHelper( request, handler, context ); } );
161 }
162
AcceptInboundCrossClusterSearchConnectionAsyncHelper(const AcceptInboundCrossClusterSearchConnectionRequest & request,const AcceptInboundCrossClusterSearchConnectionResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const163 void ElasticsearchServiceClient::AcceptInboundCrossClusterSearchConnectionAsyncHelper(const AcceptInboundCrossClusterSearchConnectionRequest& request, const AcceptInboundCrossClusterSearchConnectionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
164 {
165 handler(this, request, AcceptInboundCrossClusterSearchConnection(request), context);
166 }
167
AddTags(const AddTagsRequest & request) const168 AddTagsOutcome ElasticsearchServiceClient::AddTags(const AddTagsRequest& request) const
169 {
170 Aws::Http::URI uri = m_uri;
171 uri.AddPathSegments("/2015-01-01/tags");
172 return AddTagsOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
173 }
174
AddTagsCallable(const AddTagsRequest & request) const175 AddTagsOutcomeCallable ElasticsearchServiceClient::AddTagsCallable(const AddTagsRequest& request) const
176 {
177 auto task = Aws::MakeShared< std::packaged_task< AddTagsOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->AddTags(request); } );
178 auto packagedFunction = [task]() { (*task)(); };
179 m_executor->Submit(packagedFunction);
180 return task->get_future();
181 }
182
AddTagsAsync(const AddTagsRequest & request,const AddTagsResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const183 void ElasticsearchServiceClient::AddTagsAsync(const AddTagsRequest& request, const AddTagsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
184 {
185 m_executor->Submit( [this, request, handler, context](){ this->AddTagsAsyncHelper( request, handler, context ); } );
186 }
187
AddTagsAsyncHelper(const AddTagsRequest & request,const AddTagsResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const188 void ElasticsearchServiceClient::AddTagsAsyncHelper(const AddTagsRequest& request, const AddTagsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
189 {
190 handler(this, request, AddTags(request), context);
191 }
192
AssociatePackage(const AssociatePackageRequest & request) const193 AssociatePackageOutcome ElasticsearchServiceClient::AssociatePackage(const AssociatePackageRequest& request) const
194 {
195 if (!request.PackageIDHasBeenSet())
196 {
197 AWS_LOGSTREAM_ERROR("AssociatePackage", "Required field: PackageID, is not set");
198 return AssociatePackageOutcome(Aws::Client::AWSError<ElasticsearchServiceErrors>(ElasticsearchServiceErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [PackageID]", false));
199 }
200 if (!request.DomainNameHasBeenSet())
201 {
202 AWS_LOGSTREAM_ERROR("AssociatePackage", "Required field: DomainName, is not set");
203 return AssociatePackageOutcome(Aws::Client::AWSError<ElasticsearchServiceErrors>(ElasticsearchServiceErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [DomainName]", false));
204 }
205 Aws::Http::URI uri = m_uri;
206 uri.AddPathSegments("/2015-01-01/packages/associate/");
207 uri.AddPathSegment(request.GetPackageID());
208 uri.AddPathSegment(request.GetDomainName());
209 return AssociatePackageOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
210 }
211
AssociatePackageCallable(const AssociatePackageRequest & request) const212 AssociatePackageOutcomeCallable ElasticsearchServiceClient::AssociatePackageCallable(const AssociatePackageRequest& request) const
213 {
214 auto task = Aws::MakeShared< std::packaged_task< AssociatePackageOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->AssociatePackage(request); } );
215 auto packagedFunction = [task]() { (*task)(); };
216 m_executor->Submit(packagedFunction);
217 return task->get_future();
218 }
219
AssociatePackageAsync(const AssociatePackageRequest & request,const AssociatePackageResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const220 void ElasticsearchServiceClient::AssociatePackageAsync(const AssociatePackageRequest& request, const AssociatePackageResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
221 {
222 m_executor->Submit( [this, request, handler, context](){ this->AssociatePackageAsyncHelper( request, handler, context ); } );
223 }
224
AssociatePackageAsyncHelper(const AssociatePackageRequest & request,const AssociatePackageResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const225 void ElasticsearchServiceClient::AssociatePackageAsyncHelper(const AssociatePackageRequest& request, const AssociatePackageResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
226 {
227 handler(this, request, AssociatePackage(request), context);
228 }
229
CancelElasticsearchServiceSoftwareUpdate(const CancelElasticsearchServiceSoftwareUpdateRequest & request) const230 CancelElasticsearchServiceSoftwareUpdateOutcome ElasticsearchServiceClient::CancelElasticsearchServiceSoftwareUpdate(const CancelElasticsearchServiceSoftwareUpdateRequest& request) const
231 {
232 Aws::Http::URI uri = m_uri;
233 uri.AddPathSegments("/2015-01-01/es/serviceSoftwareUpdate/cancel");
234 return CancelElasticsearchServiceSoftwareUpdateOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
235 }
236
CancelElasticsearchServiceSoftwareUpdateCallable(const CancelElasticsearchServiceSoftwareUpdateRequest & request) const237 CancelElasticsearchServiceSoftwareUpdateOutcomeCallable ElasticsearchServiceClient::CancelElasticsearchServiceSoftwareUpdateCallable(const CancelElasticsearchServiceSoftwareUpdateRequest& request) const
238 {
239 auto task = Aws::MakeShared< std::packaged_task< CancelElasticsearchServiceSoftwareUpdateOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->CancelElasticsearchServiceSoftwareUpdate(request); } );
240 auto packagedFunction = [task]() { (*task)(); };
241 m_executor->Submit(packagedFunction);
242 return task->get_future();
243 }
244
CancelElasticsearchServiceSoftwareUpdateAsync(const CancelElasticsearchServiceSoftwareUpdateRequest & request,const CancelElasticsearchServiceSoftwareUpdateResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const245 void ElasticsearchServiceClient::CancelElasticsearchServiceSoftwareUpdateAsync(const CancelElasticsearchServiceSoftwareUpdateRequest& request, const CancelElasticsearchServiceSoftwareUpdateResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
246 {
247 m_executor->Submit( [this, request, handler, context](){ this->CancelElasticsearchServiceSoftwareUpdateAsyncHelper( request, handler, context ); } );
248 }
249
CancelElasticsearchServiceSoftwareUpdateAsyncHelper(const CancelElasticsearchServiceSoftwareUpdateRequest & request,const CancelElasticsearchServiceSoftwareUpdateResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const250 void ElasticsearchServiceClient::CancelElasticsearchServiceSoftwareUpdateAsyncHelper(const CancelElasticsearchServiceSoftwareUpdateRequest& request, const CancelElasticsearchServiceSoftwareUpdateResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
251 {
252 handler(this, request, CancelElasticsearchServiceSoftwareUpdate(request), context);
253 }
254
CreateElasticsearchDomain(const CreateElasticsearchDomainRequest & request) const255 CreateElasticsearchDomainOutcome ElasticsearchServiceClient::CreateElasticsearchDomain(const CreateElasticsearchDomainRequest& request) const
256 {
257 Aws::Http::URI uri = m_uri;
258 uri.AddPathSegments("/2015-01-01/es/domain");
259 return CreateElasticsearchDomainOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
260 }
261
CreateElasticsearchDomainCallable(const CreateElasticsearchDomainRequest & request) const262 CreateElasticsearchDomainOutcomeCallable ElasticsearchServiceClient::CreateElasticsearchDomainCallable(const CreateElasticsearchDomainRequest& request) const
263 {
264 auto task = Aws::MakeShared< std::packaged_task< CreateElasticsearchDomainOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->CreateElasticsearchDomain(request); } );
265 auto packagedFunction = [task]() { (*task)(); };
266 m_executor->Submit(packagedFunction);
267 return task->get_future();
268 }
269
CreateElasticsearchDomainAsync(const CreateElasticsearchDomainRequest & request,const CreateElasticsearchDomainResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const270 void ElasticsearchServiceClient::CreateElasticsearchDomainAsync(const CreateElasticsearchDomainRequest& request, const CreateElasticsearchDomainResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
271 {
272 m_executor->Submit( [this, request, handler, context](){ this->CreateElasticsearchDomainAsyncHelper( request, handler, context ); } );
273 }
274
CreateElasticsearchDomainAsyncHelper(const CreateElasticsearchDomainRequest & request,const CreateElasticsearchDomainResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const275 void ElasticsearchServiceClient::CreateElasticsearchDomainAsyncHelper(const CreateElasticsearchDomainRequest& request, const CreateElasticsearchDomainResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
276 {
277 handler(this, request, CreateElasticsearchDomain(request), context);
278 }
279
CreateOutboundCrossClusterSearchConnection(const CreateOutboundCrossClusterSearchConnectionRequest & request) const280 CreateOutboundCrossClusterSearchConnectionOutcome ElasticsearchServiceClient::CreateOutboundCrossClusterSearchConnection(const CreateOutboundCrossClusterSearchConnectionRequest& request) const
281 {
282 Aws::Http::URI uri = m_uri;
283 uri.AddPathSegments("/2015-01-01/es/ccs/outboundConnection");
284 return CreateOutboundCrossClusterSearchConnectionOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
285 }
286
CreateOutboundCrossClusterSearchConnectionCallable(const CreateOutboundCrossClusterSearchConnectionRequest & request) const287 CreateOutboundCrossClusterSearchConnectionOutcomeCallable ElasticsearchServiceClient::CreateOutboundCrossClusterSearchConnectionCallable(const CreateOutboundCrossClusterSearchConnectionRequest& request) const
288 {
289 auto task = Aws::MakeShared< std::packaged_task< CreateOutboundCrossClusterSearchConnectionOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->CreateOutboundCrossClusterSearchConnection(request); } );
290 auto packagedFunction = [task]() { (*task)(); };
291 m_executor->Submit(packagedFunction);
292 return task->get_future();
293 }
294
CreateOutboundCrossClusterSearchConnectionAsync(const CreateOutboundCrossClusterSearchConnectionRequest & request,const CreateOutboundCrossClusterSearchConnectionResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const295 void ElasticsearchServiceClient::CreateOutboundCrossClusterSearchConnectionAsync(const CreateOutboundCrossClusterSearchConnectionRequest& request, const CreateOutboundCrossClusterSearchConnectionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
296 {
297 m_executor->Submit( [this, request, handler, context](){ this->CreateOutboundCrossClusterSearchConnectionAsyncHelper( request, handler, context ); } );
298 }
299
CreateOutboundCrossClusterSearchConnectionAsyncHelper(const CreateOutboundCrossClusterSearchConnectionRequest & request,const CreateOutboundCrossClusterSearchConnectionResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const300 void ElasticsearchServiceClient::CreateOutboundCrossClusterSearchConnectionAsyncHelper(const CreateOutboundCrossClusterSearchConnectionRequest& request, const CreateOutboundCrossClusterSearchConnectionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
301 {
302 handler(this, request, CreateOutboundCrossClusterSearchConnection(request), context);
303 }
304
CreatePackage(const CreatePackageRequest & request) const305 CreatePackageOutcome ElasticsearchServiceClient::CreatePackage(const CreatePackageRequest& request) const
306 {
307 Aws::Http::URI uri = m_uri;
308 uri.AddPathSegments("/2015-01-01/packages");
309 return CreatePackageOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
310 }
311
CreatePackageCallable(const CreatePackageRequest & request) const312 CreatePackageOutcomeCallable ElasticsearchServiceClient::CreatePackageCallable(const CreatePackageRequest& request) const
313 {
314 auto task = Aws::MakeShared< std::packaged_task< CreatePackageOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->CreatePackage(request); } );
315 auto packagedFunction = [task]() { (*task)(); };
316 m_executor->Submit(packagedFunction);
317 return task->get_future();
318 }
319
CreatePackageAsync(const CreatePackageRequest & request,const CreatePackageResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const320 void ElasticsearchServiceClient::CreatePackageAsync(const CreatePackageRequest& request, const CreatePackageResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
321 {
322 m_executor->Submit( [this, request, handler, context](){ this->CreatePackageAsyncHelper( request, handler, context ); } );
323 }
324
CreatePackageAsyncHelper(const CreatePackageRequest & request,const CreatePackageResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const325 void ElasticsearchServiceClient::CreatePackageAsyncHelper(const CreatePackageRequest& request, const CreatePackageResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
326 {
327 handler(this, request, CreatePackage(request), context);
328 }
329
DeleteElasticsearchDomain(const DeleteElasticsearchDomainRequest & request) const330 DeleteElasticsearchDomainOutcome ElasticsearchServiceClient::DeleteElasticsearchDomain(const DeleteElasticsearchDomainRequest& request) const
331 {
332 if (!request.DomainNameHasBeenSet())
333 {
334 AWS_LOGSTREAM_ERROR("DeleteElasticsearchDomain", "Required field: DomainName, is not set");
335 return DeleteElasticsearchDomainOutcome(Aws::Client::AWSError<ElasticsearchServiceErrors>(ElasticsearchServiceErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [DomainName]", false));
336 }
337 Aws::Http::URI uri = m_uri;
338 uri.AddPathSegments("/2015-01-01/es/domain/");
339 uri.AddPathSegment(request.GetDomainName());
340 return DeleteElasticsearchDomainOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_DELETE, Aws::Auth::SIGV4_SIGNER));
341 }
342
DeleteElasticsearchDomainCallable(const DeleteElasticsearchDomainRequest & request) const343 DeleteElasticsearchDomainOutcomeCallable ElasticsearchServiceClient::DeleteElasticsearchDomainCallable(const DeleteElasticsearchDomainRequest& request) const
344 {
345 auto task = Aws::MakeShared< std::packaged_task< DeleteElasticsearchDomainOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->DeleteElasticsearchDomain(request); } );
346 auto packagedFunction = [task]() { (*task)(); };
347 m_executor->Submit(packagedFunction);
348 return task->get_future();
349 }
350
DeleteElasticsearchDomainAsync(const DeleteElasticsearchDomainRequest & request,const DeleteElasticsearchDomainResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const351 void ElasticsearchServiceClient::DeleteElasticsearchDomainAsync(const DeleteElasticsearchDomainRequest& request, const DeleteElasticsearchDomainResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
352 {
353 m_executor->Submit( [this, request, handler, context](){ this->DeleteElasticsearchDomainAsyncHelper( request, handler, context ); } );
354 }
355
DeleteElasticsearchDomainAsyncHelper(const DeleteElasticsearchDomainRequest & request,const DeleteElasticsearchDomainResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const356 void ElasticsearchServiceClient::DeleteElasticsearchDomainAsyncHelper(const DeleteElasticsearchDomainRequest& request, const DeleteElasticsearchDomainResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
357 {
358 handler(this, request, DeleteElasticsearchDomain(request), context);
359 }
360
DeleteElasticsearchServiceRole() const361 DeleteElasticsearchServiceRoleOutcome ElasticsearchServiceClient::DeleteElasticsearchServiceRole() const
362 {
363 Aws::StringStream ss;
364 ss << m_uri << "/2015-01-01/es/role";
365 return DeleteElasticsearchServiceRoleOutcome(MakeRequest(ss.str(), Aws::Http::HttpMethod::HTTP_DELETE, Aws::Auth::SIGV4_SIGNER, "DeleteElasticsearchServiceRole"));
366 }
367
DeleteElasticsearchServiceRoleCallable() const368 DeleteElasticsearchServiceRoleOutcomeCallable ElasticsearchServiceClient::DeleteElasticsearchServiceRoleCallable() const
369 {
370 auto task = Aws::MakeShared< std::packaged_task< DeleteElasticsearchServiceRoleOutcome() > >(ALLOCATION_TAG, [this](){ return this->DeleteElasticsearchServiceRole(); } );
371 auto packagedFunction = [task]() { (*task)(); };
372 m_executor->Submit(packagedFunction);
373 return task->get_future();
374 }
375
DeleteElasticsearchServiceRoleAsync(const DeleteElasticsearchServiceRoleResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const376 void ElasticsearchServiceClient::DeleteElasticsearchServiceRoleAsync(const DeleteElasticsearchServiceRoleResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
377 {
378 m_executor->Submit( [this, handler, context](){ this->DeleteElasticsearchServiceRoleAsyncHelper( handler, context ); } );
379 }
380
DeleteElasticsearchServiceRoleAsyncHelper(const DeleteElasticsearchServiceRoleResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const381 void ElasticsearchServiceClient::DeleteElasticsearchServiceRoleAsyncHelper(const DeleteElasticsearchServiceRoleResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
382 {
383 handler(this, DeleteElasticsearchServiceRole(), context);
384 }
385
DeleteInboundCrossClusterSearchConnection(const DeleteInboundCrossClusterSearchConnectionRequest & request) const386 DeleteInboundCrossClusterSearchConnectionOutcome ElasticsearchServiceClient::DeleteInboundCrossClusterSearchConnection(const DeleteInboundCrossClusterSearchConnectionRequest& request) const
387 {
388 if (!request.CrossClusterSearchConnectionIdHasBeenSet())
389 {
390 AWS_LOGSTREAM_ERROR("DeleteInboundCrossClusterSearchConnection", "Required field: CrossClusterSearchConnectionId, is not set");
391 return DeleteInboundCrossClusterSearchConnectionOutcome(Aws::Client::AWSError<ElasticsearchServiceErrors>(ElasticsearchServiceErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [CrossClusterSearchConnectionId]", false));
392 }
393 Aws::Http::URI uri = m_uri;
394 uri.AddPathSegments("/2015-01-01/es/ccs/inboundConnection/");
395 uri.AddPathSegment(request.GetCrossClusterSearchConnectionId());
396 return DeleteInboundCrossClusterSearchConnectionOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_DELETE, Aws::Auth::SIGV4_SIGNER));
397 }
398
DeleteInboundCrossClusterSearchConnectionCallable(const DeleteInboundCrossClusterSearchConnectionRequest & request) const399 DeleteInboundCrossClusterSearchConnectionOutcomeCallable ElasticsearchServiceClient::DeleteInboundCrossClusterSearchConnectionCallable(const DeleteInboundCrossClusterSearchConnectionRequest& request) const
400 {
401 auto task = Aws::MakeShared< std::packaged_task< DeleteInboundCrossClusterSearchConnectionOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->DeleteInboundCrossClusterSearchConnection(request); } );
402 auto packagedFunction = [task]() { (*task)(); };
403 m_executor->Submit(packagedFunction);
404 return task->get_future();
405 }
406
DeleteInboundCrossClusterSearchConnectionAsync(const DeleteInboundCrossClusterSearchConnectionRequest & request,const DeleteInboundCrossClusterSearchConnectionResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const407 void ElasticsearchServiceClient::DeleteInboundCrossClusterSearchConnectionAsync(const DeleteInboundCrossClusterSearchConnectionRequest& request, const DeleteInboundCrossClusterSearchConnectionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
408 {
409 m_executor->Submit( [this, request, handler, context](){ this->DeleteInboundCrossClusterSearchConnectionAsyncHelper( request, handler, context ); } );
410 }
411
DeleteInboundCrossClusterSearchConnectionAsyncHelper(const DeleteInboundCrossClusterSearchConnectionRequest & request,const DeleteInboundCrossClusterSearchConnectionResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const412 void ElasticsearchServiceClient::DeleteInboundCrossClusterSearchConnectionAsyncHelper(const DeleteInboundCrossClusterSearchConnectionRequest& request, const DeleteInboundCrossClusterSearchConnectionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
413 {
414 handler(this, request, DeleteInboundCrossClusterSearchConnection(request), context);
415 }
416
DeleteOutboundCrossClusterSearchConnection(const DeleteOutboundCrossClusterSearchConnectionRequest & request) const417 DeleteOutboundCrossClusterSearchConnectionOutcome ElasticsearchServiceClient::DeleteOutboundCrossClusterSearchConnection(const DeleteOutboundCrossClusterSearchConnectionRequest& request) const
418 {
419 if (!request.CrossClusterSearchConnectionIdHasBeenSet())
420 {
421 AWS_LOGSTREAM_ERROR("DeleteOutboundCrossClusterSearchConnection", "Required field: CrossClusterSearchConnectionId, is not set");
422 return DeleteOutboundCrossClusterSearchConnectionOutcome(Aws::Client::AWSError<ElasticsearchServiceErrors>(ElasticsearchServiceErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [CrossClusterSearchConnectionId]", false));
423 }
424 Aws::Http::URI uri = m_uri;
425 uri.AddPathSegments("/2015-01-01/es/ccs/outboundConnection/");
426 uri.AddPathSegment(request.GetCrossClusterSearchConnectionId());
427 return DeleteOutboundCrossClusterSearchConnectionOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_DELETE, Aws::Auth::SIGV4_SIGNER));
428 }
429
DeleteOutboundCrossClusterSearchConnectionCallable(const DeleteOutboundCrossClusterSearchConnectionRequest & request) const430 DeleteOutboundCrossClusterSearchConnectionOutcomeCallable ElasticsearchServiceClient::DeleteOutboundCrossClusterSearchConnectionCallable(const DeleteOutboundCrossClusterSearchConnectionRequest& request) const
431 {
432 auto task = Aws::MakeShared< std::packaged_task< DeleteOutboundCrossClusterSearchConnectionOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->DeleteOutboundCrossClusterSearchConnection(request); } );
433 auto packagedFunction = [task]() { (*task)(); };
434 m_executor->Submit(packagedFunction);
435 return task->get_future();
436 }
437
DeleteOutboundCrossClusterSearchConnectionAsync(const DeleteOutboundCrossClusterSearchConnectionRequest & request,const DeleteOutboundCrossClusterSearchConnectionResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const438 void ElasticsearchServiceClient::DeleteOutboundCrossClusterSearchConnectionAsync(const DeleteOutboundCrossClusterSearchConnectionRequest& request, const DeleteOutboundCrossClusterSearchConnectionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
439 {
440 m_executor->Submit( [this, request, handler, context](){ this->DeleteOutboundCrossClusterSearchConnectionAsyncHelper( request, handler, context ); } );
441 }
442
DeleteOutboundCrossClusterSearchConnectionAsyncHelper(const DeleteOutboundCrossClusterSearchConnectionRequest & request,const DeleteOutboundCrossClusterSearchConnectionResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const443 void ElasticsearchServiceClient::DeleteOutboundCrossClusterSearchConnectionAsyncHelper(const DeleteOutboundCrossClusterSearchConnectionRequest& request, const DeleteOutboundCrossClusterSearchConnectionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
444 {
445 handler(this, request, DeleteOutboundCrossClusterSearchConnection(request), context);
446 }
447
DeletePackage(const DeletePackageRequest & request) const448 DeletePackageOutcome ElasticsearchServiceClient::DeletePackage(const DeletePackageRequest& request) const
449 {
450 if (!request.PackageIDHasBeenSet())
451 {
452 AWS_LOGSTREAM_ERROR("DeletePackage", "Required field: PackageID, is not set");
453 return DeletePackageOutcome(Aws::Client::AWSError<ElasticsearchServiceErrors>(ElasticsearchServiceErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [PackageID]", false));
454 }
455 Aws::Http::URI uri = m_uri;
456 uri.AddPathSegments("/2015-01-01/packages/");
457 uri.AddPathSegment(request.GetPackageID());
458 return DeletePackageOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_DELETE, Aws::Auth::SIGV4_SIGNER));
459 }
460
DeletePackageCallable(const DeletePackageRequest & request) const461 DeletePackageOutcomeCallable ElasticsearchServiceClient::DeletePackageCallable(const DeletePackageRequest& request) const
462 {
463 auto task = Aws::MakeShared< std::packaged_task< DeletePackageOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->DeletePackage(request); } );
464 auto packagedFunction = [task]() { (*task)(); };
465 m_executor->Submit(packagedFunction);
466 return task->get_future();
467 }
468
DeletePackageAsync(const DeletePackageRequest & request,const DeletePackageResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const469 void ElasticsearchServiceClient::DeletePackageAsync(const DeletePackageRequest& request, const DeletePackageResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
470 {
471 m_executor->Submit( [this, request, handler, context](){ this->DeletePackageAsyncHelper( request, handler, context ); } );
472 }
473
DeletePackageAsyncHelper(const DeletePackageRequest & request,const DeletePackageResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const474 void ElasticsearchServiceClient::DeletePackageAsyncHelper(const DeletePackageRequest& request, const DeletePackageResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
475 {
476 handler(this, request, DeletePackage(request), context);
477 }
478
DescribeDomainAutoTunes(const DescribeDomainAutoTunesRequest & request) const479 DescribeDomainAutoTunesOutcome ElasticsearchServiceClient::DescribeDomainAutoTunes(const DescribeDomainAutoTunesRequest& request) const
480 {
481 if (!request.DomainNameHasBeenSet())
482 {
483 AWS_LOGSTREAM_ERROR("DescribeDomainAutoTunes", "Required field: DomainName, is not set");
484 return DescribeDomainAutoTunesOutcome(Aws::Client::AWSError<ElasticsearchServiceErrors>(ElasticsearchServiceErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [DomainName]", false));
485 }
486 Aws::Http::URI uri = m_uri;
487 uri.AddPathSegments("/2015-01-01/es/domain/");
488 uri.AddPathSegment(request.GetDomainName());
489 uri.AddPathSegments("/autoTunes");
490 return DescribeDomainAutoTunesOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_GET, Aws::Auth::SIGV4_SIGNER));
491 }
492
DescribeDomainAutoTunesCallable(const DescribeDomainAutoTunesRequest & request) const493 DescribeDomainAutoTunesOutcomeCallable ElasticsearchServiceClient::DescribeDomainAutoTunesCallable(const DescribeDomainAutoTunesRequest& request) const
494 {
495 auto task = Aws::MakeShared< std::packaged_task< DescribeDomainAutoTunesOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->DescribeDomainAutoTunes(request); } );
496 auto packagedFunction = [task]() { (*task)(); };
497 m_executor->Submit(packagedFunction);
498 return task->get_future();
499 }
500
DescribeDomainAutoTunesAsync(const DescribeDomainAutoTunesRequest & request,const DescribeDomainAutoTunesResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const501 void ElasticsearchServiceClient::DescribeDomainAutoTunesAsync(const DescribeDomainAutoTunesRequest& request, const DescribeDomainAutoTunesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
502 {
503 m_executor->Submit( [this, request, handler, context](){ this->DescribeDomainAutoTunesAsyncHelper( request, handler, context ); } );
504 }
505
DescribeDomainAutoTunesAsyncHelper(const DescribeDomainAutoTunesRequest & request,const DescribeDomainAutoTunesResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const506 void ElasticsearchServiceClient::DescribeDomainAutoTunesAsyncHelper(const DescribeDomainAutoTunesRequest& request, const DescribeDomainAutoTunesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
507 {
508 handler(this, request, DescribeDomainAutoTunes(request), context);
509 }
510
DescribeElasticsearchDomain(const DescribeElasticsearchDomainRequest & request) const511 DescribeElasticsearchDomainOutcome ElasticsearchServiceClient::DescribeElasticsearchDomain(const DescribeElasticsearchDomainRequest& request) const
512 {
513 if (!request.DomainNameHasBeenSet())
514 {
515 AWS_LOGSTREAM_ERROR("DescribeElasticsearchDomain", "Required field: DomainName, is not set");
516 return DescribeElasticsearchDomainOutcome(Aws::Client::AWSError<ElasticsearchServiceErrors>(ElasticsearchServiceErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [DomainName]", false));
517 }
518 Aws::Http::URI uri = m_uri;
519 uri.AddPathSegments("/2015-01-01/es/domain/");
520 uri.AddPathSegment(request.GetDomainName());
521 return DescribeElasticsearchDomainOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_GET, Aws::Auth::SIGV4_SIGNER));
522 }
523
DescribeElasticsearchDomainCallable(const DescribeElasticsearchDomainRequest & request) const524 DescribeElasticsearchDomainOutcomeCallable ElasticsearchServiceClient::DescribeElasticsearchDomainCallable(const DescribeElasticsearchDomainRequest& request) const
525 {
526 auto task = Aws::MakeShared< std::packaged_task< DescribeElasticsearchDomainOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->DescribeElasticsearchDomain(request); } );
527 auto packagedFunction = [task]() { (*task)(); };
528 m_executor->Submit(packagedFunction);
529 return task->get_future();
530 }
531
DescribeElasticsearchDomainAsync(const DescribeElasticsearchDomainRequest & request,const DescribeElasticsearchDomainResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const532 void ElasticsearchServiceClient::DescribeElasticsearchDomainAsync(const DescribeElasticsearchDomainRequest& request, const DescribeElasticsearchDomainResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
533 {
534 m_executor->Submit( [this, request, handler, context](){ this->DescribeElasticsearchDomainAsyncHelper( request, handler, context ); } );
535 }
536
DescribeElasticsearchDomainAsyncHelper(const DescribeElasticsearchDomainRequest & request,const DescribeElasticsearchDomainResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const537 void ElasticsearchServiceClient::DescribeElasticsearchDomainAsyncHelper(const DescribeElasticsearchDomainRequest& request, const DescribeElasticsearchDomainResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
538 {
539 handler(this, request, DescribeElasticsearchDomain(request), context);
540 }
541
DescribeElasticsearchDomainConfig(const DescribeElasticsearchDomainConfigRequest & request) const542 DescribeElasticsearchDomainConfigOutcome ElasticsearchServiceClient::DescribeElasticsearchDomainConfig(const DescribeElasticsearchDomainConfigRequest& request) const
543 {
544 if (!request.DomainNameHasBeenSet())
545 {
546 AWS_LOGSTREAM_ERROR("DescribeElasticsearchDomainConfig", "Required field: DomainName, is not set");
547 return DescribeElasticsearchDomainConfigOutcome(Aws::Client::AWSError<ElasticsearchServiceErrors>(ElasticsearchServiceErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [DomainName]", false));
548 }
549 Aws::Http::URI uri = m_uri;
550 uri.AddPathSegments("/2015-01-01/es/domain/");
551 uri.AddPathSegment(request.GetDomainName());
552 uri.AddPathSegments("/config");
553 return DescribeElasticsearchDomainConfigOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_GET, Aws::Auth::SIGV4_SIGNER));
554 }
555
DescribeElasticsearchDomainConfigCallable(const DescribeElasticsearchDomainConfigRequest & request) const556 DescribeElasticsearchDomainConfigOutcomeCallable ElasticsearchServiceClient::DescribeElasticsearchDomainConfigCallable(const DescribeElasticsearchDomainConfigRequest& request) const
557 {
558 auto task = Aws::MakeShared< std::packaged_task< DescribeElasticsearchDomainConfigOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->DescribeElasticsearchDomainConfig(request); } );
559 auto packagedFunction = [task]() { (*task)(); };
560 m_executor->Submit(packagedFunction);
561 return task->get_future();
562 }
563
DescribeElasticsearchDomainConfigAsync(const DescribeElasticsearchDomainConfigRequest & request,const DescribeElasticsearchDomainConfigResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const564 void ElasticsearchServiceClient::DescribeElasticsearchDomainConfigAsync(const DescribeElasticsearchDomainConfigRequest& request, const DescribeElasticsearchDomainConfigResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
565 {
566 m_executor->Submit( [this, request, handler, context](){ this->DescribeElasticsearchDomainConfigAsyncHelper( request, handler, context ); } );
567 }
568
DescribeElasticsearchDomainConfigAsyncHelper(const DescribeElasticsearchDomainConfigRequest & request,const DescribeElasticsearchDomainConfigResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const569 void ElasticsearchServiceClient::DescribeElasticsearchDomainConfigAsyncHelper(const DescribeElasticsearchDomainConfigRequest& request, const DescribeElasticsearchDomainConfigResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
570 {
571 handler(this, request, DescribeElasticsearchDomainConfig(request), context);
572 }
573
DescribeElasticsearchDomains(const DescribeElasticsearchDomainsRequest & request) const574 DescribeElasticsearchDomainsOutcome ElasticsearchServiceClient::DescribeElasticsearchDomains(const DescribeElasticsearchDomainsRequest& request) const
575 {
576 Aws::Http::URI uri = m_uri;
577 uri.AddPathSegments("/2015-01-01/es/domain-info");
578 return DescribeElasticsearchDomainsOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
579 }
580
DescribeElasticsearchDomainsCallable(const DescribeElasticsearchDomainsRequest & request) const581 DescribeElasticsearchDomainsOutcomeCallable ElasticsearchServiceClient::DescribeElasticsearchDomainsCallable(const DescribeElasticsearchDomainsRequest& request) const
582 {
583 auto task = Aws::MakeShared< std::packaged_task< DescribeElasticsearchDomainsOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->DescribeElasticsearchDomains(request); } );
584 auto packagedFunction = [task]() { (*task)(); };
585 m_executor->Submit(packagedFunction);
586 return task->get_future();
587 }
588
DescribeElasticsearchDomainsAsync(const DescribeElasticsearchDomainsRequest & request,const DescribeElasticsearchDomainsResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const589 void ElasticsearchServiceClient::DescribeElasticsearchDomainsAsync(const DescribeElasticsearchDomainsRequest& request, const DescribeElasticsearchDomainsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
590 {
591 m_executor->Submit( [this, request, handler, context](){ this->DescribeElasticsearchDomainsAsyncHelper( request, handler, context ); } );
592 }
593
DescribeElasticsearchDomainsAsyncHelper(const DescribeElasticsearchDomainsRequest & request,const DescribeElasticsearchDomainsResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const594 void ElasticsearchServiceClient::DescribeElasticsearchDomainsAsyncHelper(const DescribeElasticsearchDomainsRequest& request, const DescribeElasticsearchDomainsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
595 {
596 handler(this, request, DescribeElasticsearchDomains(request), context);
597 }
598
DescribeElasticsearchInstanceTypeLimits(const DescribeElasticsearchInstanceTypeLimitsRequest & request) const599 DescribeElasticsearchInstanceTypeLimitsOutcome ElasticsearchServiceClient::DescribeElasticsearchInstanceTypeLimits(const DescribeElasticsearchInstanceTypeLimitsRequest& request) const
600 {
601 if (!request.InstanceTypeHasBeenSet())
602 {
603 AWS_LOGSTREAM_ERROR("DescribeElasticsearchInstanceTypeLimits", "Required field: InstanceType, is not set");
604 return DescribeElasticsearchInstanceTypeLimitsOutcome(Aws::Client::AWSError<ElasticsearchServiceErrors>(ElasticsearchServiceErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [InstanceType]", false));
605 }
606 if (!request.ElasticsearchVersionHasBeenSet())
607 {
608 AWS_LOGSTREAM_ERROR("DescribeElasticsearchInstanceTypeLimits", "Required field: ElasticsearchVersion, is not set");
609 return DescribeElasticsearchInstanceTypeLimitsOutcome(Aws::Client::AWSError<ElasticsearchServiceErrors>(ElasticsearchServiceErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [ElasticsearchVersion]", false));
610 }
611 Aws::Http::URI uri = m_uri;
612 uri.AddPathSegments("/2015-01-01/es/instanceTypeLimits/");
613 uri.AddPathSegment(request.GetElasticsearchVersion());
614 uri.AddPathSegment(ESPartitionInstanceTypeMapper::GetNameForESPartitionInstanceType(request.GetInstanceType()));
615 return DescribeElasticsearchInstanceTypeLimitsOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_GET, Aws::Auth::SIGV4_SIGNER));
616 }
617
DescribeElasticsearchInstanceTypeLimitsCallable(const DescribeElasticsearchInstanceTypeLimitsRequest & request) const618 DescribeElasticsearchInstanceTypeLimitsOutcomeCallable ElasticsearchServiceClient::DescribeElasticsearchInstanceTypeLimitsCallable(const DescribeElasticsearchInstanceTypeLimitsRequest& request) const
619 {
620 auto task = Aws::MakeShared< std::packaged_task< DescribeElasticsearchInstanceTypeLimitsOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->DescribeElasticsearchInstanceTypeLimits(request); } );
621 auto packagedFunction = [task]() { (*task)(); };
622 m_executor->Submit(packagedFunction);
623 return task->get_future();
624 }
625
DescribeElasticsearchInstanceTypeLimitsAsync(const DescribeElasticsearchInstanceTypeLimitsRequest & request,const DescribeElasticsearchInstanceTypeLimitsResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const626 void ElasticsearchServiceClient::DescribeElasticsearchInstanceTypeLimitsAsync(const DescribeElasticsearchInstanceTypeLimitsRequest& request, const DescribeElasticsearchInstanceTypeLimitsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
627 {
628 m_executor->Submit( [this, request, handler, context](){ this->DescribeElasticsearchInstanceTypeLimitsAsyncHelper( request, handler, context ); } );
629 }
630
DescribeElasticsearchInstanceTypeLimitsAsyncHelper(const DescribeElasticsearchInstanceTypeLimitsRequest & request,const DescribeElasticsearchInstanceTypeLimitsResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const631 void ElasticsearchServiceClient::DescribeElasticsearchInstanceTypeLimitsAsyncHelper(const DescribeElasticsearchInstanceTypeLimitsRequest& request, const DescribeElasticsearchInstanceTypeLimitsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
632 {
633 handler(this, request, DescribeElasticsearchInstanceTypeLimits(request), context);
634 }
635
DescribeInboundCrossClusterSearchConnections(const DescribeInboundCrossClusterSearchConnectionsRequest & request) const636 DescribeInboundCrossClusterSearchConnectionsOutcome ElasticsearchServiceClient::DescribeInboundCrossClusterSearchConnections(const DescribeInboundCrossClusterSearchConnectionsRequest& request) const
637 {
638 Aws::Http::URI uri = m_uri;
639 uri.AddPathSegments("/2015-01-01/es/ccs/inboundConnection/search");
640 return DescribeInboundCrossClusterSearchConnectionsOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
641 }
642
DescribeInboundCrossClusterSearchConnectionsCallable(const DescribeInboundCrossClusterSearchConnectionsRequest & request) const643 DescribeInboundCrossClusterSearchConnectionsOutcomeCallable ElasticsearchServiceClient::DescribeInboundCrossClusterSearchConnectionsCallable(const DescribeInboundCrossClusterSearchConnectionsRequest& request) const
644 {
645 auto task = Aws::MakeShared< std::packaged_task< DescribeInboundCrossClusterSearchConnectionsOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->DescribeInboundCrossClusterSearchConnections(request); } );
646 auto packagedFunction = [task]() { (*task)(); };
647 m_executor->Submit(packagedFunction);
648 return task->get_future();
649 }
650
DescribeInboundCrossClusterSearchConnectionsAsync(const DescribeInboundCrossClusterSearchConnectionsRequest & request,const DescribeInboundCrossClusterSearchConnectionsResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const651 void ElasticsearchServiceClient::DescribeInboundCrossClusterSearchConnectionsAsync(const DescribeInboundCrossClusterSearchConnectionsRequest& request, const DescribeInboundCrossClusterSearchConnectionsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
652 {
653 m_executor->Submit( [this, request, handler, context](){ this->DescribeInboundCrossClusterSearchConnectionsAsyncHelper( request, handler, context ); } );
654 }
655
DescribeInboundCrossClusterSearchConnectionsAsyncHelper(const DescribeInboundCrossClusterSearchConnectionsRequest & request,const DescribeInboundCrossClusterSearchConnectionsResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const656 void ElasticsearchServiceClient::DescribeInboundCrossClusterSearchConnectionsAsyncHelper(const DescribeInboundCrossClusterSearchConnectionsRequest& request, const DescribeInboundCrossClusterSearchConnectionsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
657 {
658 handler(this, request, DescribeInboundCrossClusterSearchConnections(request), context);
659 }
660
DescribeOutboundCrossClusterSearchConnections(const DescribeOutboundCrossClusterSearchConnectionsRequest & request) const661 DescribeOutboundCrossClusterSearchConnectionsOutcome ElasticsearchServiceClient::DescribeOutboundCrossClusterSearchConnections(const DescribeOutboundCrossClusterSearchConnectionsRequest& request) const
662 {
663 Aws::Http::URI uri = m_uri;
664 uri.AddPathSegments("/2015-01-01/es/ccs/outboundConnection/search");
665 return DescribeOutboundCrossClusterSearchConnectionsOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
666 }
667
DescribeOutboundCrossClusterSearchConnectionsCallable(const DescribeOutboundCrossClusterSearchConnectionsRequest & request) const668 DescribeOutboundCrossClusterSearchConnectionsOutcomeCallable ElasticsearchServiceClient::DescribeOutboundCrossClusterSearchConnectionsCallable(const DescribeOutboundCrossClusterSearchConnectionsRequest& request) const
669 {
670 auto task = Aws::MakeShared< std::packaged_task< DescribeOutboundCrossClusterSearchConnectionsOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->DescribeOutboundCrossClusterSearchConnections(request); } );
671 auto packagedFunction = [task]() { (*task)(); };
672 m_executor->Submit(packagedFunction);
673 return task->get_future();
674 }
675
DescribeOutboundCrossClusterSearchConnectionsAsync(const DescribeOutboundCrossClusterSearchConnectionsRequest & request,const DescribeOutboundCrossClusterSearchConnectionsResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const676 void ElasticsearchServiceClient::DescribeOutboundCrossClusterSearchConnectionsAsync(const DescribeOutboundCrossClusterSearchConnectionsRequest& request, const DescribeOutboundCrossClusterSearchConnectionsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
677 {
678 m_executor->Submit( [this, request, handler, context](){ this->DescribeOutboundCrossClusterSearchConnectionsAsyncHelper( request, handler, context ); } );
679 }
680
DescribeOutboundCrossClusterSearchConnectionsAsyncHelper(const DescribeOutboundCrossClusterSearchConnectionsRequest & request,const DescribeOutboundCrossClusterSearchConnectionsResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const681 void ElasticsearchServiceClient::DescribeOutboundCrossClusterSearchConnectionsAsyncHelper(const DescribeOutboundCrossClusterSearchConnectionsRequest& request, const DescribeOutboundCrossClusterSearchConnectionsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
682 {
683 handler(this, request, DescribeOutboundCrossClusterSearchConnections(request), context);
684 }
685
DescribePackages(const DescribePackagesRequest & request) const686 DescribePackagesOutcome ElasticsearchServiceClient::DescribePackages(const DescribePackagesRequest& request) const
687 {
688 Aws::Http::URI uri = m_uri;
689 uri.AddPathSegments("/2015-01-01/packages/describe");
690 return DescribePackagesOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
691 }
692
DescribePackagesCallable(const DescribePackagesRequest & request) const693 DescribePackagesOutcomeCallable ElasticsearchServiceClient::DescribePackagesCallable(const DescribePackagesRequest& request) const
694 {
695 auto task = Aws::MakeShared< std::packaged_task< DescribePackagesOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->DescribePackages(request); } );
696 auto packagedFunction = [task]() { (*task)(); };
697 m_executor->Submit(packagedFunction);
698 return task->get_future();
699 }
700
DescribePackagesAsync(const DescribePackagesRequest & request,const DescribePackagesResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const701 void ElasticsearchServiceClient::DescribePackagesAsync(const DescribePackagesRequest& request, const DescribePackagesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
702 {
703 m_executor->Submit( [this, request, handler, context](){ this->DescribePackagesAsyncHelper( request, handler, context ); } );
704 }
705
DescribePackagesAsyncHelper(const DescribePackagesRequest & request,const DescribePackagesResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const706 void ElasticsearchServiceClient::DescribePackagesAsyncHelper(const DescribePackagesRequest& request, const DescribePackagesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
707 {
708 handler(this, request, DescribePackages(request), context);
709 }
710
DescribeReservedElasticsearchInstanceOfferings(const DescribeReservedElasticsearchInstanceOfferingsRequest & request) const711 DescribeReservedElasticsearchInstanceOfferingsOutcome ElasticsearchServiceClient::DescribeReservedElasticsearchInstanceOfferings(const DescribeReservedElasticsearchInstanceOfferingsRequest& request) const
712 {
713 Aws::Http::URI uri = m_uri;
714 uri.AddPathSegments("/2015-01-01/es/reservedInstanceOfferings");
715 return DescribeReservedElasticsearchInstanceOfferingsOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_GET, Aws::Auth::SIGV4_SIGNER));
716 }
717
DescribeReservedElasticsearchInstanceOfferingsCallable(const DescribeReservedElasticsearchInstanceOfferingsRequest & request) const718 DescribeReservedElasticsearchInstanceOfferingsOutcomeCallable ElasticsearchServiceClient::DescribeReservedElasticsearchInstanceOfferingsCallable(const DescribeReservedElasticsearchInstanceOfferingsRequest& request) const
719 {
720 auto task = Aws::MakeShared< std::packaged_task< DescribeReservedElasticsearchInstanceOfferingsOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->DescribeReservedElasticsearchInstanceOfferings(request); } );
721 auto packagedFunction = [task]() { (*task)(); };
722 m_executor->Submit(packagedFunction);
723 return task->get_future();
724 }
725
DescribeReservedElasticsearchInstanceOfferingsAsync(const DescribeReservedElasticsearchInstanceOfferingsRequest & request,const DescribeReservedElasticsearchInstanceOfferingsResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const726 void ElasticsearchServiceClient::DescribeReservedElasticsearchInstanceOfferingsAsync(const DescribeReservedElasticsearchInstanceOfferingsRequest& request, const DescribeReservedElasticsearchInstanceOfferingsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
727 {
728 m_executor->Submit( [this, request, handler, context](){ this->DescribeReservedElasticsearchInstanceOfferingsAsyncHelper( request, handler, context ); } );
729 }
730
DescribeReservedElasticsearchInstanceOfferingsAsyncHelper(const DescribeReservedElasticsearchInstanceOfferingsRequest & request,const DescribeReservedElasticsearchInstanceOfferingsResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const731 void ElasticsearchServiceClient::DescribeReservedElasticsearchInstanceOfferingsAsyncHelper(const DescribeReservedElasticsearchInstanceOfferingsRequest& request, const DescribeReservedElasticsearchInstanceOfferingsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
732 {
733 handler(this, request, DescribeReservedElasticsearchInstanceOfferings(request), context);
734 }
735
DescribeReservedElasticsearchInstances(const DescribeReservedElasticsearchInstancesRequest & request) const736 DescribeReservedElasticsearchInstancesOutcome ElasticsearchServiceClient::DescribeReservedElasticsearchInstances(const DescribeReservedElasticsearchInstancesRequest& request) const
737 {
738 Aws::Http::URI uri = m_uri;
739 uri.AddPathSegments("/2015-01-01/es/reservedInstances");
740 return DescribeReservedElasticsearchInstancesOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_GET, Aws::Auth::SIGV4_SIGNER));
741 }
742
DescribeReservedElasticsearchInstancesCallable(const DescribeReservedElasticsearchInstancesRequest & request) const743 DescribeReservedElasticsearchInstancesOutcomeCallable ElasticsearchServiceClient::DescribeReservedElasticsearchInstancesCallable(const DescribeReservedElasticsearchInstancesRequest& request) const
744 {
745 auto task = Aws::MakeShared< std::packaged_task< DescribeReservedElasticsearchInstancesOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->DescribeReservedElasticsearchInstances(request); } );
746 auto packagedFunction = [task]() { (*task)(); };
747 m_executor->Submit(packagedFunction);
748 return task->get_future();
749 }
750
DescribeReservedElasticsearchInstancesAsync(const DescribeReservedElasticsearchInstancesRequest & request,const DescribeReservedElasticsearchInstancesResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const751 void ElasticsearchServiceClient::DescribeReservedElasticsearchInstancesAsync(const DescribeReservedElasticsearchInstancesRequest& request, const DescribeReservedElasticsearchInstancesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
752 {
753 m_executor->Submit( [this, request, handler, context](){ this->DescribeReservedElasticsearchInstancesAsyncHelper( request, handler, context ); } );
754 }
755
DescribeReservedElasticsearchInstancesAsyncHelper(const DescribeReservedElasticsearchInstancesRequest & request,const DescribeReservedElasticsearchInstancesResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const756 void ElasticsearchServiceClient::DescribeReservedElasticsearchInstancesAsyncHelper(const DescribeReservedElasticsearchInstancesRequest& request, const DescribeReservedElasticsearchInstancesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
757 {
758 handler(this, request, DescribeReservedElasticsearchInstances(request), context);
759 }
760
DissociatePackage(const DissociatePackageRequest & request) const761 DissociatePackageOutcome ElasticsearchServiceClient::DissociatePackage(const DissociatePackageRequest& request) const
762 {
763 if (!request.PackageIDHasBeenSet())
764 {
765 AWS_LOGSTREAM_ERROR("DissociatePackage", "Required field: PackageID, is not set");
766 return DissociatePackageOutcome(Aws::Client::AWSError<ElasticsearchServiceErrors>(ElasticsearchServiceErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [PackageID]", false));
767 }
768 if (!request.DomainNameHasBeenSet())
769 {
770 AWS_LOGSTREAM_ERROR("DissociatePackage", "Required field: DomainName, is not set");
771 return DissociatePackageOutcome(Aws::Client::AWSError<ElasticsearchServiceErrors>(ElasticsearchServiceErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [DomainName]", false));
772 }
773 Aws::Http::URI uri = m_uri;
774 uri.AddPathSegments("/2015-01-01/packages/dissociate/");
775 uri.AddPathSegment(request.GetPackageID());
776 uri.AddPathSegment(request.GetDomainName());
777 return DissociatePackageOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
778 }
779
DissociatePackageCallable(const DissociatePackageRequest & request) const780 DissociatePackageOutcomeCallable ElasticsearchServiceClient::DissociatePackageCallable(const DissociatePackageRequest& request) const
781 {
782 auto task = Aws::MakeShared< std::packaged_task< DissociatePackageOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->DissociatePackage(request); } );
783 auto packagedFunction = [task]() { (*task)(); };
784 m_executor->Submit(packagedFunction);
785 return task->get_future();
786 }
787
DissociatePackageAsync(const DissociatePackageRequest & request,const DissociatePackageResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const788 void ElasticsearchServiceClient::DissociatePackageAsync(const DissociatePackageRequest& request, const DissociatePackageResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
789 {
790 m_executor->Submit( [this, request, handler, context](){ this->DissociatePackageAsyncHelper( request, handler, context ); } );
791 }
792
DissociatePackageAsyncHelper(const DissociatePackageRequest & request,const DissociatePackageResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const793 void ElasticsearchServiceClient::DissociatePackageAsyncHelper(const DissociatePackageRequest& request, const DissociatePackageResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
794 {
795 handler(this, request, DissociatePackage(request), context);
796 }
797
GetCompatibleElasticsearchVersions(const GetCompatibleElasticsearchVersionsRequest & request) const798 GetCompatibleElasticsearchVersionsOutcome ElasticsearchServiceClient::GetCompatibleElasticsearchVersions(const GetCompatibleElasticsearchVersionsRequest& request) const
799 {
800 Aws::Http::URI uri = m_uri;
801 uri.AddPathSegments("/2015-01-01/es/compatibleVersions");
802 return GetCompatibleElasticsearchVersionsOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_GET, Aws::Auth::SIGV4_SIGNER));
803 }
804
GetCompatibleElasticsearchVersionsCallable(const GetCompatibleElasticsearchVersionsRequest & request) const805 GetCompatibleElasticsearchVersionsOutcomeCallable ElasticsearchServiceClient::GetCompatibleElasticsearchVersionsCallable(const GetCompatibleElasticsearchVersionsRequest& request) const
806 {
807 auto task = Aws::MakeShared< std::packaged_task< GetCompatibleElasticsearchVersionsOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->GetCompatibleElasticsearchVersions(request); } );
808 auto packagedFunction = [task]() { (*task)(); };
809 m_executor->Submit(packagedFunction);
810 return task->get_future();
811 }
812
GetCompatibleElasticsearchVersionsAsync(const GetCompatibleElasticsearchVersionsRequest & request,const GetCompatibleElasticsearchVersionsResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const813 void ElasticsearchServiceClient::GetCompatibleElasticsearchVersionsAsync(const GetCompatibleElasticsearchVersionsRequest& request, const GetCompatibleElasticsearchVersionsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
814 {
815 m_executor->Submit( [this, request, handler, context](){ this->GetCompatibleElasticsearchVersionsAsyncHelper( request, handler, context ); } );
816 }
817
GetCompatibleElasticsearchVersionsAsyncHelper(const GetCompatibleElasticsearchVersionsRequest & request,const GetCompatibleElasticsearchVersionsResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const818 void ElasticsearchServiceClient::GetCompatibleElasticsearchVersionsAsyncHelper(const GetCompatibleElasticsearchVersionsRequest& request, const GetCompatibleElasticsearchVersionsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
819 {
820 handler(this, request, GetCompatibleElasticsearchVersions(request), context);
821 }
822
GetPackageVersionHistory(const GetPackageVersionHistoryRequest & request) const823 GetPackageVersionHistoryOutcome ElasticsearchServiceClient::GetPackageVersionHistory(const GetPackageVersionHistoryRequest& request) const
824 {
825 if (!request.PackageIDHasBeenSet())
826 {
827 AWS_LOGSTREAM_ERROR("GetPackageVersionHistory", "Required field: PackageID, is not set");
828 return GetPackageVersionHistoryOutcome(Aws::Client::AWSError<ElasticsearchServiceErrors>(ElasticsearchServiceErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [PackageID]", false));
829 }
830 Aws::Http::URI uri = m_uri;
831 uri.AddPathSegments("/2015-01-01/packages/");
832 uri.AddPathSegment(request.GetPackageID());
833 uri.AddPathSegments("/history");
834 return GetPackageVersionHistoryOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_GET, Aws::Auth::SIGV4_SIGNER));
835 }
836
GetPackageVersionHistoryCallable(const GetPackageVersionHistoryRequest & request) const837 GetPackageVersionHistoryOutcomeCallable ElasticsearchServiceClient::GetPackageVersionHistoryCallable(const GetPackageVersionHistoryRequest& request) const
838 {
839 auto task = Aws::MakeShared< std::packaged_task< GetPackageVersionHistoryOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->GetPackageVersionHistory(request); } );
840 auto packagedFunction = [task]() { (*task)(); };
841 m_executor->Submit(packagedFunction);
842 return task->get_future();
843 }
844
GetPackageVersionHistoryAsync(const GetPackageVersionHistoryRequest & request,const GetPackageVersionHistoryResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const845 void ElasticsearchServiceClient::GetPackageVersionHistoryAsync(const GetPackageVersionHistoryRequest& request, const GetPackageVersionHistoryResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
846 {
847 m_executor->Submit( [this, request, handler, context](){ this->GetPackageVersionHistoryAsyncHelper( request, handler, context ); } );
848 }
849
GetPackageVersionHistoryAsyncHelper(const GetPackageVersionHistoryRequest & request,const GetPackageVersionHistoryResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const850 void ElasticsearchServiceClient::GetPackageVersionHistoryAsyncHelper(const GetPackageVersionHistoryRequest& request, const GetPackageVersionHistoryResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
851 {
852 handler(this, request, GetPackageVersionHistory(request), context);
853 }
854
GetUpgradeHistory(const GetUpgradeHistoryRequest & request) const855 GetUpgradeHistoryOutcome ElasticsearchServiceClient::GetUpgradeHistory(const GetUpgradeHistoryRequest& request) const
856 {
857 if (!request.DomainNameHasBeenSet())
858 {
859 AWS_LOGSTREAM_ERROR("GetUpgradeHistory", "Required field: DomainName, is not set");
860 return GetUpgradeHistoryOutcome(Aws::Client::AWSError<ElasticsearchServiceErrors>(ElasticsearchServiceErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [DomainName]", false));
861 }
862 Aws::Http::URI uri = m_uri;
863 uri.AddPathSegments("/2015-01-01/es/upgradeDomain/");
864 uri.AddPathSegment(request.GetDomainName());
865 uri.AddPathSegments("/history");
866 return GetUpgradeHistoryOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_GET, Aws::Auth::SIGV4_SIGNER));
867 }
868
GetUpgradeHistoryCallable(const GetUpgradeHistoryRequest & request) const869 GetUpgradeHistoryOutcomeCallable ElasticsearchServiceClient::GetUpgradeHistoryCallable(const GetUpgradeHistoryRequest& request) const
870 {
871 auto task = Aws::MakeShared< std::packaged_task< GetUpgradeHistoryOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->GetUpgradeHistory(request); } );
872 auto packagedFunction = [task]() { (*task)(); };
873 m_executor->Submit(packagedFunction);
874 return task->get_future();
875 }
876
GetUpgradeHistoryAsync(const GetUpgradeHistoryRequest & request,const GetUpgradeHistoryResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const877 void ElasticsearchServiceClient::GetUpgradeHistoryAsync(const GetUpgradeHistoryRequest& request, const GetUpgradeHistoryResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
878 {
879 m_executor->Submit( [this, request, handler, context](){ this->GetUpgradeHistoryAsyncHelper( request, handler, context ); } );
880 }
881
GetUpgradeHistoryAsyncHelper(const GetUpgradeHistoryRequest & request,const GetUpgradeHistoryResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const882 void ElasticsearchServiceClient::GetUpgradeHistoryAsyncHelper(const GetUpgradeHistoryRequest& request, const GetUpgradeHistoryResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
883 {
884 handler(this, request, GetUpgradeHistory(request), context);
885 }
886
GetUpgradeStatus(const GetUpgradeStatusRequest & request) const887 GetUpgradeStatusOutcome ElasticsearchServiceClient::GetUpgradeStatus(const GetUpgradeStatusRequest& request) const
888 {
889 if (!request.DomainNameHasBeenSet())
890 {
891 AWS_LOGSTREAM_ERROR("GetUpgradeStatus", "Required field: DomainName, is not set");
892 return GetUpgradeStatusOutcome(Aws::Client::AWSError<ElasticsearchServiceErrors>(ElasticsearchServiceErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [DomainName]", false));
893 }
894 Aws::Http::URI uri = m_uri;
895 uri.AddPathSegments("/2015-01-01/es/upgradeDomain/");
896 uri.AddPathSegment(request.GetDomainName());
897 uri.AddPathSegments("/status");
898 return GetUpgradeStatusOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_GET, Aws::Auth::SIGV4_SIGNER));
899 }
900
GetUpgradeStatusCallable(const GetUpgradeStatusRequest & request) const901 GetUpgradeStatusOutcomeCallable ElasticsearchServiceClient::GetUpgradeStatusCallable(const GetUpgradeStatusRequest& request) const
902 {
903 auto task = Aws::MakeShared< std::packaged_task< GetUpgradeStatusOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->GetUpgradeStatus(request); } );
904 auto packagedFunction = [task]() { (*task)(); };
905 m_executor->Submit(packagedFunction);
906 return task->get_future();
907 }
908
GetUpgradeStatusAsync(const GetUpgradeStatusRequest & request,const GetUpgradeStatusResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const909 void ElasticsearchServiceClient::GetUpgradeStatusAsync(const GetUpgradeStatusRequest& request, const GetUpgradeStatusResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
910 {
911 m_executor->Submit( [this, request, handler, context](){ this->GetUpgradeStatusAsyncHelper( request, handler, context ); } );
912 }
913
GetUpgradeStatusAsyncHelper(const GetUpgradeStatusRequest & request,const GetUpgradeStatusResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const914 void ElasticsearchServiceClient::GetUpgradeStatusAsyncHelper(const GetUpgradeStatusRequest& request, const GetUpgradeStatusResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
915 {
916 handler(this, request, GetUpgradeStatus(request), context);
917 }
918
ListDomainNames(const ListDomainNamesRequest & request) const919 ListDomainNamesOutcome ElasticsearchServiceClient::ListDomainNames(const ListDomainNamesRequest& request) const
920 {
921 Aws::Http::URI uri = m_uri;
922 uri.AddPathSegments("/2015-01-01/domain");
923 return ListDomainNamesOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_GET, Aws::Auth::SIGV4_SIGNER));
924 }
925
ListDomainNamesCallable(const ListDomainNamesRequest & request) const926 ListDomainNamesOutcomeCallable ElasticsearchServiceClient::ListDomainNamesCallable(const ListDomainNamesRequest& request) const
927 {
928 auto task = Aws::MakeShared< std::packaged_task< ListDomainNamesOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->ListDomainNames(request); } );
929 auto packagedFunction = [task]() { (*task)(); };
930 m_executor->Submit(packagedFunction);
931 return task->get_future();
932 }
933
ListDomainNamesAsync(const ListDomainNamesRequest & request,const ListDomainNamesResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const934 void ElasticsearchServiceClient::ListDomainNamesAsync(const ListDomainNamesRequest& request, const ListDomainNamesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
935 {
936 m_executor->Submit( [this, request, handler, context](){ this->ListDomainNamesAsyncHelper( request, handler, context ); } );
937 }
938
ListDomainNamesAsyncHelper(const ListDomainNamesRequest & request,const ListDomainNamesResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const939 void ElasticsearchServiceClient::ListDomainNamesAsyncHelper(const ListDomainNamesRequest& request, const ListDomainNamesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
940 {
941 handler(this, request, ListDomainNames(request), context);
942 }
943
ListDomainsForPackage(const ListDomainsForPackageRequest & request) const944 ListDomainsForPackageOutcome ElasticsearchServiceClient::ListDomainsForPackage(const ListDomainsForPackageRequest& request) const
945 {
946 if (!request.PackageIDHasBeenSet())
947 {
948 AWS_LOGSTREAM_ERROR("ListDomainsForPackage", "Required field: PackageID, is not set");
949 return ListDomainsForPackageOutcome(Aws::Client::AWSError<ElasticsearchServiceErrors>(ElasticsearchServiceErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [PackageID]", false));
950 }
951 Aws::Http::URI uri = m_uri;
952 uri.AddPathSegments("/2015-01-01/packages/");
953 uri.AddPathSegment(request.GetPackageID());
954 uri.AddPathSegments("/domains");
955 return ListDomainsForPackageOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_GET, Aws::Auth::SIGV4_SIGNER));
956 }
957
ListDomainsForPackageCallable(const ListDomainsForPackageRequest & request) const958 ListDomainsForPackageOutcomeCallable ElasticsearchServiceClient::ListDomainsForPackageCallable(const ListDomainsForPackageRequest& request) const
959 {
960 auto task = Aws::MakeShared< std::packaged_task< ListDomainsForPackageOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->ListDomainsForPackage(request); } );
961 auto packagedFunction = [task]() { (*task)(); };
962 m_executor->Submit(packagedFunction);
963 return task->get_future();
964 }
965
ListDomainsForPackageAsync(const ListDomainsForPackageRequest & request,const ListDomainsForPackageResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const966 void ElasticsearchServiceClient::ListDomainsForPackageAsync(const ListDomainsForPackageRequest& request, const ListDomainsForPackageResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
967 {
968 m_executor->Submit( [this, request, handler, context](){ this->ListDomainsForPackageAsyncHelper( request, handler, context ); } );
969 }
970
ListDomainsForPackageAsyncHelper(const ListDomainsForPackageRequest & request,const ListDomainsForPackageResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const971 void ElasticsearchServiceClient::ListDomainsForPackageAsyncHelper(const ListDomainsForPackageRequest& request, const ListDomainsForPackageResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
972 {
973 handler(this, request, ListDomainsForPackage(request), context);
974 }
975
ListElasticsearchInstanceTypes(const ListElasticsearchInstanceTypesRequest & request) const976 ListElasticsearchInstanceTypesOutcome ElasticsearchServiceClient::ListElasticsearchInstanceTypes(const ListElasticsearchInstanceTypesRequest& request) const
977 {
978 if (!request.ElasticsearchVersionHasBeenSet())
979 {
980 AWS_LOGSTREAM_ERROR("ListElasticsearchInstanceTypes", "Required field: ElasticsearchVersion, is not set");
981 return ListElasticsearchInstanceTypesOutcome(Aws::Client::AWSError<ElasticsearchServiceErrors>(ElasticsearchServiceErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [ElasticsearchVersion]", false));
982 }
983 Aws::Http::URI uri = m_uri;
984 uri.AddPathSegments("/2015-01-01/es/instanceTypes/");
985 uri.AddPathSegment(request.GetElasticsearchVersion());
986 return ListElasticsearchInstanceTypesOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_GET, Aws::Auth::SIGV4_SIGNER));
987 }
988
ListElasticsearchInstanceTypesCallable(const ListElasticsearchInstanceTypesRequest & request) const989 ListElasticsearchInstanceTypesOutcomeCallable ElasticsearchServiceClient::ListElasticsearchInstanceTypesCallable(const ListElasticsearchInstanceTypesRequest& request) const
990 {
991 auto task = Aws::MakeShared< std::packaged_task< ListElasticsearchInstanceTypesOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->ListElasticsearchInstanceTypes(request); } );
992 auto packagedFunction = [task]() { (*task)(); };
993 m_executor->Submit(packagedFunction);
994 return task->get_future();
995 }
996
ListElasticsearchInstanceTypesAsync(const ListElasticsearchInstanceTypesRequest & request,const ListElasticsearchInstanceTypesResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const997 void ElasticsearchServiceClient::ListElasticsearchInstanceTypesAsync(const ListElasticsearchInstanceTypesRequest& request, const ListElasticsearchInstanceTypesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
998 {
999 m_executor->Submit( [this, request, handler, context](){ this->ListElasticsearchInstanceTypesAsyncHelper( request, handler, context ); } );
1000 }
1001
ListElasticsearchInstanceTypesAsyncHelper(const ListElasticsearchInstanceTypesRequest & request,const ListElasticsearchInstanceTypesResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1002 void ElasticsearchServiceClient::ListElasticsearchInstanceTypesAsyncHelper(const ListElasticsearchInstanceTypesRequest& request, const ListElasticsearchInstanceTypesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1003 {
1004 handler(this, request, ListElasticsearchInstanceTypes(request), context);
1005 }
1006
ListElasticsearchVersions(const ListElasticsearchVersionsRequest & request) const1007 ListElasticsearchVersionsOutcome ElasticsearchServiceClient::ListElasticsearchVersions(const ListElasticsearchVersionsRequest& request) const
1008 {
1009 Aws::Http::URI uri = m_uri;
1010 uri.AddPathSegments("/2015-01-01/es/versions");
1011 return ListElasticsearchVersionsOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_GET, Aws::Auth::SIGV4_SIGNER));
1012 }
1013
ListElasticsearchVersionsCallable(const ListElasticsearchVersionsRequest & request) const1014 ListElasticsearchVersionsOutcomeCallable ElasticsearchServiceClient::ListElasticsearchVersionsCallable(const ListElasticsearchVersionsRequest& request) const
1015 {
1016 auto task = Aws::MakeShared< std::packaged_task< ListElasticsearchVersionsOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->ListElasticsearchVersions(request); } );
1017 auto packagedFunction = [task]() { (*task)(); };
1018 m_executor->Submit(packagedFunction);
1019 return task->get_future();
1020 }
1021
ListElasticsearchVersionsAsync(const ListElasticsearchVersionsRequest & request,const ListElasticsearchVersionsResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1022 void ElasticsearchServiceClient::ListElasticsearchVersionsAsync(const ListElasticsearchVersionsRequest& request, const ListElasticsearchVersionsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1023 {
1024 m_executor->Submit( [this, request, handler, context](){ this->ListElasticsearchVersionsAsyncHelper( request, handler, context ); } );
1025 }
1026
ListElasticsearchVersionsAsyncHelper(const ListElasticsearchVersionsRequest & request,const ListElasticsearchVersionsResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1027 void ElasticsearchServiceClient::ListElasticsearchVersionsAsyncHelper(const ListElasticsearchVersionsRequest& request, const ListElasticsearchVersionsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1028 {
1029 handler(this, request, ListElasticsearchVersions(request), context);
1030 }
1031
ListPackagesForDomain(const ListPackagesForDomainRequest & request) const1032 ListPackagesForDomainOutcome ElasticsearchServiceClient::ListPackagesForDomain(const ListPackagesForDomainRequest& request) const
1033 {
1034 if (!request.DomainNameHasBeenSet())
1035 {
1036 AWS_LOGSTREAM_ERROR("ListPackagesForDomain", "Required field: DomainName, is not set");
1037 return ListPackagesForDomainOutcome(Aws::Client::AWSError<ElasticsearchServiceErrors>(ElasticsearchServiceErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [DomainName]", false));
1038 }
1039 Aws::Http::URI uri = m_uri;
1040 uri.AddPathSegments("/2015-01-01/domain/");
1041 uri.AddPathSegment(request.GetDomainName());
1042 uri.AddPathSegments("/packages");
1043 return ListPackagesForDomainOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_GET, Aws::Auth::SIGV4_SIGNER));
1044 }
1045
ListPackagesForDomainCallable(const ListPackagesForDomainRequest & request) const1046 ListPackagesForDomainOutcomeCallable ElasticsearchServiceClient::ListPackagesForDomainCallable(const ListPackagesForDomainRequest& request) const
1047 {
1048 auto task = Aws::MakeShared< std::packaged_task< ListPackagesForDomainOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->ListPackagesForDomain(request); } );
1049 auto packagedFunction = [task]() { (*task)(); };
1050 m_executor->Submit(packagedFunction);
1051 return task->get_future();
1052 }
1053
ListPackagesForDomainAsync(const ListPackagesForDomainRequest & request,const ListPackagesForDomainResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1054 void ElasticsearchServiceClient::ListPackagesForDomainAsync(const ListPackagesForDomainRequest& request, const ListPackagesForDomainResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1055 {
1056 m_executor->Submit( [this, request, handler, context](){ this->ListPackagesForDomainAsyncHelper( request, handler, context ); } );
1057 }
1058
ListPackagesForDomainAsyncHelper(const ListPackagesForDomainRequest & request,const ListPackagesForDomainResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1059 void ElasticsearchServiceClient::ListPackagesForDomainAsyncHelper(const ListPackagesForDomainRequest& request, const ListPackagesForDomainResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1060 {
1061 handler(this, request, ListPackagesForDomain(request), context);
1062 }
1063
ListTags(const ListTagsRequest & request) const1064 ListTagsOutcome ElasticsearchServiceClient::ListTags(const ListTagsRequest& request) const
1065 {
1066 if (!request.ARNHasBeenSet())
1067 {
1068 AWS_LOGSTREAM_ERROR("ListTags", "Required field: ARN, is not set");
1069 return ListTagsOutcome(Aws::Client::AWSError<ElasticsearchServiceErrors>(ElasticsearchServiceErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [ARN]", false));
1070 }
1071 Aws::Http::URI uri = m_uri;
1072 uri.AddPathSegments("/2015-01-01/tags/");
1073 return ListTagsOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_GET, Aws::Auth::SIGV4_SIGNER));
1074 }
1075
ListTagsCallable(const ListTagsRequest & request) const1076 ListTagsOutcomeCallable ElasticsearchServiceClient::ListTagsCallable(const ListTagsRequest& request) const
1077 {
1078 auto task = Aws::MakeShared< std::packaged_task< ListTagsOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->ListTags(request); } );
1079 auto packagedFunction = [task]() { (*task)(); };
1080 m_executor->Submit(packagedFunction);
1081 return task->get_future();
1082 }
1083
ListTagsAsync(const ListTagsRequest & request,const ListTagsResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1084 void ElasticsearchServiceClient::ListTagsAsync(const ListTagsRequest& request, const ListTagsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1085 {
1086 m_executor->Submit( [this, request, handler, context](){ this->ListTagsAsyncHelper( request, handler, context ); } );
1087 }
1088
ListTagsAsyncHelper(const ListTagsRequest & request,const ListTagsResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1089 void ElasticsearchServiceClient::ListTagsAsyncHelper(const ListTagsRequest& request, const ListTagsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1090 {
1091 handler(this, request, ListTags(request), context);
1092 }
1093
PurchaseReservedElasticsearchInstanceOffering(const PurchaseReservedElasticsearchInstanceOfferingRequest & request) const1094 PurchaseReservedElasticsearchInstanceOfferingOutcome ElasticsearchServiceClient::PurchaseReservedElasticsearchInstanceOffering(const PurchaseReservedElasticsearchInstanceOfferingRequest& request) const
1095 {
1096 Aws::Http::URI uri = m_uri;
1097 uri.AddPathSegments("/2015-01-01/es/purchaseReservedInstanceOffering");
1098 return PurchaseReservedElasticsearchInstanceOfferingOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
1099 }
1100
PurchaseReservedElasticsearchInstanceOfferingCallable(const PurchaseReservedElasticsearchInstanceOfferingRequest & request) const1101 PurchaseReservedElasticsearchInstanceOfferingOutcomeCallable ElasticsearchServiceClient::PurchaseReservedElasticsearchInstanceOfferingCallable(const PurchaseReservedElasticsearchInstanceOfferingRequest& request) const
1102 {
1103 auto task = Aws::MakeShared< std::packaged_task< PurchaseReservedElasticsearchInstanceOfferingOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->PurchaseReservedElasticsearchInstanceOffering(request); } );
1104 auto packagedFunction = [task]() { (*task)(); };
1105 m_executor->Submit(packagedFunction);
1106 return task->get_future();
1107 }
1108
PurchaseReservedElasticsearchInstanceOfferingAsync(const PurchaseReservedElasticsearchInstanceOfferingRequest & request,const PurchaseReservedElasticsearchInstanceOfferingResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1109 void ElasticsearchServiceClient::PurchaseReservedElasticsearchInstanceOfferingAsync(const PurchaseReservedElasticsearchInstanceOfferingRequest& request, const PurchaseReservedElasticsearchInstanceOfferingResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1110 {
1111 m_executor->Submit( [this, request, handler, context](){ this->PurchaseReservedElasticsearchInstanceOfferingAsyncHelper( request, handler, context ); } );
1112 }
1113
PurchaseReservedElasticsearchInstanceOfferingAsyncHelper(const PurchaseReservedElasticsearchInstanceOfferingRequest & request,const PurchaseReservedElasticsearchInstanceOfferingResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1114 void ElasticsearchServiceClient::PurchaseReservedElasticsearchInstanceOfferingAsyncHelper(const PurchaseReservedElasticsearchInstanceOfferingRequest& request, const PurchaseReservedElasticsearchInstanceOfferingResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1115 {
1116 handler(this, request, PurchaseReservedElasticsearchInstanceOffering(request), context);
1117 }
1118
RejectInboundCrossClusterSearchConnection(const RejectInboundCrossClusterSearchConnectionRequest & request) const1119 RejectInboundCrossClusterSearchConnectionOutcome ElasticsearchServiceClient::RejectInboundCrossClusterSearchConnection(const RejectInboundCrossClusterSearchConnectionRequest& request) const
1120 {
1121 if (!request.CrossClusterSearchConnectionIdHasBeenSet())
1122 {
1123 AWS_LOGSTREAM_ERROR("RejectInboundCrossClusterSearchConnection", "Required field: CrossClusterSearchConnectionId, is not set");
1124 return RejectInboundCrossClusterSearchConnectionOutcome(Aws::Client::AWSError<ElasticsearchServiceErrors>(ElasticsearchServiceErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [CrossClusterSearchConnectionId]", false));
1125 }
1126 Aws::Http::URI uri = m_uri;
1127 uri.AddPathSegments("/2015-01-01/es/ccs/inboundConnection/");
1128 uri.AddPathSegment(request.GetCrossClusterSearchConnectionId());
1129 uri.AddPathSegments("/reject");
1130 return RejectInboundCrossClusterSearchConnectionOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_PUT, Aws::Auth::SIGV4_SIGNER));
1131 }
1132
RejectInboundCrossClusterSearchConnectionCallable(const RejectInboundCrossClusterSearchConnectionRequest & request) const1133 RejectInboundCrossClusterSearchConnectionOutcomeCallable ElasticsearchServiceClient::RejectInboundCrossClusterSearchConnectionCallable(const RejectInboundCrossClusterSearchConnectionRequest& request) const
1134 {
1135 auto task = Aws::MakeShared< std::packaged_task< RejectInboundCrossClusterSearchConnectionOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->RejectInboundCrossClusterSearchConnection(request); } );
1136 auto packagedFunction = [task]() { (*task)(); };
1137 m_executor->Submit(packagedFunction);
1138 return task->get_future();
1139 }
1140
RejectInboundCrossClusterSearchConnectionAsync(const RejectInboundCrossClusterSearchConnectionRequest & request,const RejectInboundCrossClusterSearchConnectionResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1141 void ElasticsearchServiceClient::RejectInboundCrossClusterSearchConnectionAsync(const RejectInboundCrossClusterSearchConnectionRequest& request, const RejectInboundCrossClusterSearchConnectionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1142 {
1143 m_executor->Submit( [this, request, handler, context](){ this->RejectInboundCrossClusterSearchConnectionAsyncHelper( request, handler, context ); } );
1144 }
1145
RejectInboundCrossClusterSearchConnectionAsyncHelper(const RejectInboundCrossClusterSearchConnectionRequest & request,const RejectInboundCrossClusterSearchConnectionResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1146 void ElasticsearchServiceClient::RejectInboundCrossClusterSearchConnectionAsyncHelper(const RejectInboundCrossClusterSearchConnectionRequest& request, const RejectInboundCrossClusterSearchConnectionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1147 {
1148 handler(this, request, RejectInboundCrossClusterSearchConnection(request), context);
1149 }
1150
RemoveTags(const RemoveTagsRequest & request) const1151 RemoveTagsOutcome ElasticsearchServiceClient::RemoveTags(const RemoveTagsRequest& request) const
1152 {
1153 Aws::Http::URI uri = m_uri;
1154 uri.AddPathSegments("/2015-01-01/tags-removal");
1155 return RemoveTagsOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
1156 }
1157
RemoveTagsCallable(const RemoveTagsRequest & request) const1158 RemoveTagsOutcomeCallable ElasticsearchServiceClient::RemoveTagsCallable(const RemoveTagsRequest& request) const
1159 {
1160 auto task = Aws::MakeShared< std::packaged_task< RemoveTagsOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->RemoveTags(request); } );
1161 auto packagedFunction = [task]() { (*task)(); };
1162 m_executor->Submit(packagedFunction);
1163 return task->get_future();
1164 }
1165
RemoveTagsAsync(const RemoveTagsRequest & request,const RemoveTagsResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1166 void ElasticsearchServiceClient::RemoveTagsAsync(const RemoveTagsRequest& request, const RemoveTagsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1167 {
1168 m_executor->Submit( [this, request, handler, context](){ this->RemoveTagsAsyncHelper( request, handler, context ); } );
1169 }
1170
RemoveTagsAsyncHelper(const RemoveTagsRequest & request,const RemoveTagsResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1171 void ElasticsearchServiceClient::RemoveTagsAsyncHelper(const RemoveTagsRequest& request, const RemoveTagsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1172 {
1173 handler(this, request, RemoveTags(request), context);
1174 }
1175
StartElasticsearchServiceSoftwareUpdate(const StartElasticsearchServiceSoftwareUpdateRequest & request) const1176 StartElasticsearchServiceSoftwareUpdateOutcome ElasticsearchServiceClient::StartElasticsearchServiceSoftwareUpdate(const StartElasticsearchServiceSoftwareUpdateRequest& request) const
1177 {
1178 Aws::Http::URI uri = m_uri;
1179 uri.AddPathSegments("/2015-01-01/es/serviceSoftwareUpdate/start");
1180 return StartElasticsearchServiceSoftwareUpdateOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
1181 }
1182
StartElasticsearchServiceSoftwareUpdateCallable(const StartElasticsearchServiceSoftwareUpdateRequest & request) const1183 StartElasticsearchServiceSoftwareUpdateOutcomeCallable ElasticsearchServiceClient::StartElasticsearchServiceSoftwareUpdateCallable(const StartElasticsearchServiceSoftwareUpdateRequest& request) const
1184 {
1185 auto task = Aws::MakeShared< std::packaged_task< StartElasticsearchServiceSoftwareUpdateOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->StartElasticsearchServiceSoftwareUpdate(request); } );
1186 auto packagedFunction = [task]() { (*task)(); };
1187 m_executor->Submit(packagedFunction);
1188 return task->get_future();
1189 }
1190
StartElasticsearchServiceSoftwareUpdateAsync(const StartElasticsearchServiceSoftwareUpdateRequest & request,const StartElasticsearchServiceSoftwareUpdateResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1191 void ElasticsearchServiceClient::StartElasticsearchServiceSoftwareUpdateAsync(const StartElasticsearchServiceSoftwareUpdateRequest& request, const StartElasticsearchServiceSoftwareUpdateResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1192 {
1193 m_executor->Submit( [this, request, handler, context](){ this->StartElasticsearchServiceSoftwareUpdateAsyncHelper( request, handler, context ); } );
1194 }
1195
StartElasticsearchServiceSoftwareUpdateAsyncHelper(const StartElasticsearchServiceSoftwareUpdateRequest & request,const StartElasticsearchServiceSoftwareUpdateResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1196 void ElasticsearchServiceClient::StartElasticsearchServiceSoftwareUpdateAsyncHelper(const StartElasticsearchServiceSoftwareUpdateRequest& request, const StartElasticsearchServiceSoftwareUpdateResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1197 {
1198 handler(this, request, StartElasticsearchServiceSoftwareUpdate(request), context);
1199 }
1200
UpdateElasticsearchDomainConfig(const UpdateElasticsearchDomainConfigRequest & request) const1201 UpdateElasticsearchDomainConfigOutcome ElasticsearchServiceClient::UpdateElasticsearchDomainConfig(const UpdateElasticsearchDomainConfigRequest& request) const
1202 {
1203 if (!request.DomainNameHasBeenSet())
1204 {
1205 AWS_LOGSTREAM_ERROR("UpdateElasticsearchDomainConfig", "Required field: DomainName, is not set");
1206 return UpdateElasticsearchDomainConfigOutcome(Aws::Client::AWSError<ElasticsearchServiceErrors>(ElasticsearchServiceErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [DomainName]", false));
1207 }
1208 Aws::Http::URI uri = m_uri;
1209 uri.AddPathSegments("/2015-01-01/es/domain/");
1210 uri.AddPathSegment(request.GetDomainName());
1211 uri.AddPathSegments("/config");
1212 return UpdateElasticsearchDomainConfigOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
1213 }
1214
UpdateElasticsearchDomainConfigCallable(const UpdateElasticsearchDomainConfigRequest & request) const1215 UpdateElasticsearchDomainConfigOutcomeCallable ElasticsearchServiceClient::UpdateElasticsearchDomainConfigCallable(const UpdateElasticsearchDomainConfigRequest& request) const
1216 {
1217 auto task = Aws::MakeShared< std::packaged_task< UpdateElasticsearchDomainConfigOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->UpdateElasticsearchDomainConfig(request); } );
1218 auto packagedFunction = [task]() { (*task)(); };
1219 m_executor->Submit(packagedFunction);
1220 return task->get_future();
1221 }
1222
UpdateElasticsearchDomainConfigAsync(const UpdateElasticsearchDomainConfigRequest & request,const UpdateElasticsearchDomainConfigResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1223 void ElasticsearchServiceClient::UpdateElasticsearchDomainConfigAsync(const UpdateElasticsearchDomainConfigRequest& request, const UpdateElasticsearchDomainConfigResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1224 {
1225 m_executor->Submit( [this, request, handler, context](){ this->UpdateElasticsearchDomainConfigAsyncHelper( request, handler, context ); } );
1226 }
1227
UpdateElasticsearchDomainConfigAsyncHelper(const UpdateElasticsearchDomainConfigRequest & request,const UpdateElasticsearchDomainConfigResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1228 void ElasticsearchServiceClient::UpdateElasticsearchDomainConfigAsyncHelper(const UpdateElasticsearchDomainConfigRequest& request, const UpdateElasticsearchDomainConfigResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1229 {
1230 handler(this, request, UpdateElasticsearchDomainConfig(request), context);
1231 }
1232
UpdatePackage(const UpdatePackageRequest & request) const1233 UpdatePackageOutcome ElasticsearchServiceClient::UpdatePackage(const UpdatePackageRequest& request) const
1234 {
1235 Aws::Http::URI uri = m_uri;
1236 uri.AddPathSegments("/2015-01-01/packages/update");
1237 return UpdatePackageOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
1238 }
1239
UpdatePackageCallable(const UpdatePackageRequest & request) const1240 UpdatePackageOutcomeCallable ElasticsearchServiceClient::UpdatePackageCallable(const UpdatePackageRequest& request) const
1241 {
1242 auto task = Aws::MakeShared< std::packaged_task< UpdatePackageOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->UpdatePackage(request); } );
1243 auto packagedFunction = [task]() { (*task)(); };
1244 m_executor->Submit(packagedFunction);
1245 return task->get_future();
1246 }
1247
UpdatePackageAsync(const UpdatePackageRequest & request,const UpdatePackageResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1248 void ElasticsearchServiceClient::UpdatePackageAsync(const UpdatePackageRequest& request, const UpdatePackageResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1249 {
1250 m_executor->Submit( [this, request, handler, context](){ this->UpdatePackageAsyncHelper( request, handler, context ); } );
1251 }
1252
UpdatePackageAsyncHelper(const UpdatePackageRequest & request,const UpdatePackageResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1253 void ElasticsearchServiceClient::UpdatePackageAsyncHelper(const UpdatePackageRequest& request, const UpdatePackageResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1254 {
1255 handler(this, request, UpdatePackage(request), context);
1256 }
1257
UpgradeElasticsearchDomain(const UpgradeElasticsearchDomainRequest & request) const1258 UpgradeElasticsearchDomainOutcome ElasticsearchServiceClient::UpgradeElasticsearchDomain(const UpgradeElasticsearchDomainRequest& request) const
1259 {
1260 Aws::Http::URI uri = m_uri;
1261 uri.AddPathSegments("/2015-01-01/es/upgradeDomain");
1262 return UpgradeElasticsearchDomainOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
1263 }
1264
UpgradeElasticsearchDomainCallable(const UpgradeElasticsearchDomainRequest & request) const1265 UpgradeElasticsearchDomainOutcomeCallable ElasticsearchServiceClient::UpgradeElasticsearchDomainCallable(const UpgradeElasticsearchDomainRequest& request) const
1266 {
1267 auto task = Aws::MakeShared< std::packaged_task< UpgradeElasticsearchDomainOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->UpgradeElasticsearchDomain(request); } );
1268 auto packagedFunction = [task]() { (*task)(); };
1269 m_executor->Submit(packagedFunction);
1270 return task->get_future();
1271 }
1272
UpgradeElasticsearchDomainAsync(const UpgradeElasticsearchDomainRequest & request,const UpgradeElasticsearchDomainResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1273 void ElasticsearchServiceClient::UpgradeElasticsearchDomainAsync(const UpgradeElasticsearchDomainRequest& request, const UpgradeElasticsearchDomainResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1274 {
1275 m_executor->Submit( [this, request, handler, context](){ this->UpgradeElasticsearchDomainAsyncHelper( request, handler, context ); } );
1276 }
1277
UpgradeElasticsearchDomainAsyncHelper(const UpgradeElasticsearchDomainRequest & request,const UpgradeElasticsearchDomainResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1278 void ElasticsearchServiceClient::UpgradeElasticsearchDomainAsyncHelper(const UpgradeElasticsearchDomainRequest& request, const UpgradeElasticsearchDomainResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1279 {
1280 handler(this, request, UpgradeElasticsearchDomain(request), context);
1281 }
1282
1283