Waiter codegen plugin + waiters (#3752)

* Updated waiter template to accept a templated PathMatcher per acceptor rather than per waiter

* Waiter codegen project

* Waiter codegen tests

* Update crtp client inheritance & python script for smithy codegen

* Add proper state chaining in Waiter.h

* Add mapping for lost c2j errors to error code

* Updated clients

* Add namespace mapping to WaiterCodeGenPlugin

* generate Waiter.h for clients that don't have waiters modeled

* Seperate different acceptors into seperate structs/classes

* Update codegen to use new Acceptor structs

* Return Optional<Shape> in private methods of CollectionElementTypeResolver

* Add userAgent metrics for waiters

* Updated waiters

* Transition the waiter to the failure state if none of the acceptors are matched and an error was encountered

* change std::vector to Aws::Vector (why do i forget this everytime)

* Updated waiter files

* Include handling for smithy 1.0 enum modeling (string shape with enum trait)

* Resolve cpp type from FilterPredicateEmitter for inner types instead of auto

* Updated waiters

* Resolve enum for filterOperandEmitter paths

* Fix type resolution for map types

* Empty waiter generation for legacy services (no smithy model)

* Add medialive XXXSdkResult.h mappings

* Enum resolution for ScalarEmitters (OR edge case)

* dont generate waiters for deprecated operations

* fix .template dependent compilation error

* Refactor client integ tests that use polling logic to use waiters now

* Fix windows ambigious lambda constructor issue

* Explicitly define bool return type for pathMatcher lambdas

* Updated waiters

* Fix map collision for waiter name's that are generated and stored

* Updated waiters

* Fix namespace mapping default to be '{}' (dev purposes)

* Remove && for pathacceptor argument

* cast std::count_if to size_t since it returns a signed value

* Updated waiters

* ONLY static cast when we are comparing to a collection.size()

* Updated waiters

Author: sbaluja

generated/src/aws-cpp-sdk-AWSMigrationHub/include/aws/AWSMigrationHub/MigrationHubClient.h

@@ -6,6 +6,7 @@
 #pragma once
 #include <aws/AWSMigrationHub/MigrationHubPaginationBase.h>
 #include <aws/AWSMigrationHub/MigrationHubServiceClientModel.h>
+#include <aws/AWSMigrationHub/MigrationHubWaiter.h>
 #include <aws/AWSMigrationHub/MigrationHub_EXPORTS.h>
 #include <aws/core/client/AWSClient.h>
 #include <aws/core/client/AWSClientAsyncCRTP.h>
@@ -24,7 +25,8 @@ namespace MigrationHub {
  */
 class AWS_MIGRATIONHUB_API MigrationHubClient : public Aws::Client::AWSJsonClient,
                                                 public Aws::Client::ClientWithAsyncTemplateMethods<MigrationHubClient>,
-                                                public MigrationHubPaginationBase<MigrationHubClient> {
+                                                public MigrationHubPaginationBase<MigrationHubClient>,
+                                                public MigrationHubWaiter<MigrationHubClient> {
  public:
   typedef Aws::Client::AWSJsonClient BASECLASS;
   static const char* GetServiceName();

generated/src/aws-cpp-sdk-AWSMigrationHub/include/aws/AWSMigrationHub/MigrationHubWaiter.h

@@ -0,0 +1,21 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/AWSMigrationHub/MigrationHubClient.h>
+#include <aws/core/utils/Waiter.h>
+#include <aws/core/utils/memory/AWSMemory.h>
+
+#include <algorithm>
+
+namespace Aws {
+namespace MigrationHub {
+
+template <typename DerivedClient = MigrationHubClient>
+class MigrationHubWaiter {
+ public:
+};
+}  // namespace MigrationHub
+}  // namespace Aws

generated/src/aws-cpp-sdk-accessanalyzer/include/aws/accessanalyzer/AccessAnalyzerClient.h

@@ -6,6 +6,7 @@
 #pragma once
 #include <aws/accessanalyzer/AccessAnalyzerPaginationBase.h>
 #include <aws/accessanalyzer/AccessAnalyzerServiceClientModel.h>
+#include <aws/accessanalyzer/AccessAnalyzerWaiter.h>
 #include <aws/accessanalyzer/AccessAnalyzer_EXPORTS.h>
 #include <aws/core/client/AWSClient.h>
 #include <aws/core/client/AWSClientAsyncCRTP.h>
@@ -49,7 +50,8 @@ namespace AccessAnalyzer {
  */
 class AWS_ACCESSANALYZER_API AccessAnalyzerClient : public Aws::Client::AWSJsonClient,
                                                     public Aws::Client::ClientWithAsyncTemplateMethods<AccessAnalyzerClient>,
-                                                    public AccessAnalyzerPaginationBase<AccessAnalyzerClient> {
+                                                    public AccessAnalyzerPaginationBase<AccessAnalyzerClient>,
+                                                    public AccessAnalyzerWaiter<AccessAnalyzerClient> {
  public:
   typedef Aws::Client::AWSJsonClient BASECLASS;
   static const char* GetServiceName();

generated/src/aws-cpp-sdk-accessanalyzer/include/aws/accessanalyzer/AccessAnalyzerWaiter.h

@@ -0,0 +1,21 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/accessanalyzer/AccessAnalyzerClient.h>
+#include <aws/core/utils/Waiter.h>
+#include <aws/core/utils/memory/AWSMemory.h>
+
+#include <algorithm>
+
+namespace Aws {
+namespace AccessAnalyzer {
+
+template <typename DerivedClient = AccessAnalyzerClient>
+class AccessAnalyzerWaiter {
+ public:
+};
+}  // namespace AccessAnalyzer
+}  // namespace Aws

generated/src/aws-cpp-sdk-account/include/aws/account/AccountClient.h

@@ -6,6 +6,7 @@
 #pragma once
 #include <aws/account/AccountPaginationBase.h>
 #include <aws/account/AccountServiceClientModel.h>
+#include <aws/account/AccountWaiter.h>
 #include <aws/account/Account_EXPORTS.h>
 #include <aws/core/client/AWSClient.h>
 #include <aws/core/client/AWSClientAsyncCRTP.h>
@@ -19,7 +20,8 @@ namespace Account {
  */
 class AWS_ACCOUNT_API AccountClient : public Aws::Client::AWSJsonClient,
                                       public Aws::Client::ClientWithAsyncTemplateMethods<AccountClient>,
-                                      public AccountPaginationBase<AccountClient> {
+                                      public AccountPaginationBase<AccountClient>,
+                                      public AccountWaiter<AccountClient> {
  public:
   typedef Aws::Client::AWSJsonClient BASECLASS;
   static const char* GetServiceName();

generated/src/aws-cpp-sdk-account/include/aws/account/AccountWaiter.h

@@ -0,0 +1,21 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/account/AccountClient.h>
+#include <aws/core/utils/Waiter.h>
+#include <aws/core/utils/memory/AWSMemory.h>
+
+#include <algorithm>
+
+namespace Aws {
+namespace Account {
+
+template <typename DerivedClient = AccountClient>
+class AccountWaiter {
+ public:
+};
+}  // namespace Account
+}  // namespace Aws

generated/src/aws-cpp-sdk-acm-pca/include/aws/acm-pca/ACMPCAClient.h

@@ -6,6 +6,7 @@
 #pragma once
 #include <aws/acm-pca/ACMPCAPaginationBase.h>
 #include <aws/acm-pca/ACMPCAServiceClientModel.h>
+#include <aws/acm-pca/ACMPCAWaiter.h>
 #include <aws/acm-pca/ACMPCA_EXPORTS.h>
 #include <aws/core/client/AWSClient.h>
 #include <aws/core/client/AWSClientAsyncCRTP.h>
@@ -40,7 +41,8 @@ namespace ACMPCA {
  */
 class AWS_ACMPCA_API ACMPCAClient : public Aws::Client::AWSJsonClient,
                                     public Aws::Client::ClientWithAsyncTemplateMethods<ACMPCAClient>,
-                                    public ACMPCAPaginationBase<ACMPCAClient> {
+                                    public ACMPCAPaginationBase<ACMPCAClient>,
+                                    public ACMPCAWaiter<ACMPCAClient> {
  public:
   typedef Aws::Client::AWSJsonClient BASECLASS;
   static const char* GetServiceName();

generated/src/aws-cpp-sdk-acm-pca/include/aws/acm-pca/ACMPCAWaiter.h

@@ -0,0 +1,89 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/acm-pca/ACMPCAClient.h>
+#include <aws/acm-pca/model/AuditReportStatus.h>
+#include <aws/acm-pca/model/DescribeCertificateAuthorityAuditReportRequest.h>
+#include <aws/acm-pca/model/DescribeCertificateAuthorityAuditReportResult.h>
+#include <aws/acm-pca/model/GetCertificateAuthorityCsrRequest.h>
+#include <aws/acm-pca/model/GetCertificateAuthorityCsrResult.h>
+#include <aws/acm-pca/model/GetCertificateRequest.h>
+#include <aws/acm-pca/model/GetCertificateResult.h>
+#include <aws/core/utils/Waiter.h>
+#include <aws/core/utils/memory/AWSMemory.h>
+
+#include <algorithm>
+
+namespace Aws {
+namespace ACMPCA {
+
+template <typename DerivedClient = ACMPCAClient>
+class ACMPCAWaiter {
+ public:
+  Aws::Utils::WaiterOutcome<Model::DescribeCertificateAuthorityAuditReportOutcome> WaitUntilAuditReportCreated(
+      const Model::DescribeCertificateAuthorityAuditReportRequest& request) {
+    using OutcomeT = Model::DescribeCertificateAuthorityAuditReportOutcome;
+    using RequestT = Model::DescribeCertificateAuthorityAuditReportRequest;
+    Aws::Vector<Aws::UniquePtr<Aws::Utils::Acceptor<OutcomeT>>> acceptors;
+    acceptors.emplace_back(Aws::MakeUnique<Aws::Utils::PathAcceptor<OutcomeT>>(
+        "AuditReportCreatedWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("SUCCESS"),
+        [](const Model::DescribeCertificateAuthorityAuditReportOutcome& outcome, const Aws::Utils::ExpectedValue& expected) -> bool {
+          if (!outcome.IsSuccess()) return false;
+          const auto& result = outcome.GetResult();
+          return Model::AuditReportStatusMapper::GetNameForAuditReportStatus(result.GetAuditReportStatus()) == expected.get<Aws::String>();
+        }));
+    acceptors.emplace_back(Aws::MakeUnique<Aws::Utils::PathAcceptor<OutcomeT>>(
+        "AuditReportCreatedWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("FAILED"),
+        [](const Model::DescribeCertificateAuthorityAuditReportOutcome& outcome, const Aws::Utils::ExpectedValue& expected) -> bool {
+          if (!outcome.IsSuccess()) return false;
+          const auto& result = outcome.GetResult();
+          return Model::AuditReportStatusMapper::GetNameForAuditReportStatus(result.GetAuditReportStatus()) == expected.get<Aws::String>();
+        }));
+    acceptors.emplace_back(Aws::MakeUnique<Aws::Utils::ErrorAcceptor<OutcomeT>>(
+        "AuditReportCreatedWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("AccessDeniedException")));
+
+    auto operation = [this](const RequestT& req) {
+      return static_cast<DerivedClient*>(this)->DescribeCertificateAuthorityAuditReport(req);
+    };
+    Aws::Utils::Waiter<RequestT, OutcomeT> waiter(3, 60, std::move(acceptors), operation, "WaitUntilAuditReportCreated");
+    return waiter.Wait(request);
+  }
+
+  Aws::Utils::WaiterOutcome<Model::GetCertificateOutcome> WaitUntilCertificateIssued(const Model::GetCertificateRequest& request) {
+    using OutcomeT = Model::GetCertificateOutcome;
+    using RequestT = Model::GetCertificateRequest;
+    Aws::Vector<Aws::UniquePtr<Aws::Utils::Acceptor<OutcomeT>>> acceptors;
+    acceptors.emplace_back(
+        Aws::MakeUnique<Aws::Utils::ErrorAcceptor<OutcomeT>>("CertificateIssuedWaiter", Aws::Utils::WaiterState::SUCCESS, false));
+    acceptors.emplace_back(Aws::MakeUnique<Aws::Utils::ErrorAcceptor<OutcomeT>>("CertificateIssuedWaiter", Aws::Utils::WaiterState::RETRY,
+                                                                                Aws::String("RequestInProgressException")));
+    acceptors.emplace_back(Aws::MakeUnique<Aws::Utils::ErrorAcceptor<OutcomeT>>("CertificateIssuedWaiter", Aws::Utils::WaiterState::FAILURE,
+                                                                                Aws::String("AccessDeniedException")));
+
+    auto operation = [this](const RequestT& req) { return static_cast<DerivedClient*>(this)->GetCertificate(req); };
+    Aws::Utils::Waiter<RequestT, OutcomeT> waiter(1, 60, std::move(acceptors), operation, "WaitUntilCertificateIssued");
+    return waiter.Wait(request);
+  }
+
+  Aws::Utils::WaiterOutcome<Model::GetCertificateAuthorityCsrOutcome> WaitUntilCertificateAuthorityCSRCreated(
+      const Model::GetCertificateAuthorityCsrRequest& request) {
+    using OutcomeT = Model::GetCertificateAuthorityCsrOutcome;
+    using RequestT = Model::GetCertificateAuthorityCsrRequest;
+    Aws::Vector<Aws::UniquePtr<Aws::Utils::Acceptor<OutcomeT>>> acceptors;
+    acceptors.emplace_back(Aws::MakeUnique<Aws::Utils::ErrorAcceptor<OutcomeT>>("CertificateAuthorityCSRCreatedWaiter",
+                                                                                Aws::Utils::WaiterState::SUCCESS, false));
+    acceptors.emplace_back(Aws::MakeUnique<Aws::Utils::ErrorAcceptor<OutcomeT>>(
+        "CertificateAuthorityCSRCreatedWaiter", Aws::Utils::WaiterState::RETRY, Aws::String("RequestInProgressException")));
+    acceptors.emplace_back(Aws::MakeUnique<Aws::Utils::ErrorAcceptor<OutcomeT>>(
+        "CertificateAuthorityCSRCreatedWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("AccessDeniedException")));
+
+    auto operation = [this](const RequestT& req) { return static_cast<DerivedClient*>(this)->GetCertificateAuthorityCsr(req); };
+    Aws::Utils::Waiter<RequestT, OutcomeT> waiter(3, 60, std::move(acceptors), operation, "WaitUntilCertificateAuthorityCSRCreated");
+    return waiter.Wait(request);
+  }
+};
+}  // namespace ACMPCA
+}  // namespace Aws

generated/src/aws-cpp-sdk-acm/include/aws/acm/ACMClient.h

@@ -6,6 +6,7 @@
 #pragma once
 #include <aws/acm/ACMPaginationBase.h>
 #include <aws/acm/ACMServiceClientModel.h>
+#include <aws/acm/ACMWaiter.h>
 #include <aws/acm/ACM_EXPORTS.h>
 #include <aws/core/client/AWSClient.h>
 #include <aws/core/client/AWSClientAsyncCRTP.h>
@@ -23,7 +24,8 @@ namespace ACM {
  */
 class AWS_ACM_API ACMClient : public Aws::Client::AWSJsonClient,
                               public Aws::Client::ClientWithAsyncTemplateMethods<ACMClient>,
-                              public ACMPaginationBase<ACMClient> {
+                              public ACMPaginationBase<ACMClient>,
+                              public ACMWaiter<ACMClient> {
  public:
   typedef Aws::Client::AWSJsonClient BASECLASS;
   static const char* GetServiceName();

generated/src/aws-cpp-sdk-acm/include/aws/acm/ACMWaiter.h

@@ -0,0 +1,67 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/acm/ACMClient.h>
+#include <aws/acm/model/CertificateStatus.h>
+#include <aws/acm/model/DescribeCertificateRequest.h>
+#include <aws/acm/model/DescribeCertificateResult.h>
+#include <aws/acm/model/DomainStatus.h>
+#include <aws/core/utils/Waiter.h>
+#include <aws/core/utils/memory/AWSMemory.h>
+
+#include <algorithm>
+
+namespace Aws {
+namespace ACM {
+
+template <typename DerivedClient = ACMClient>
+class ACMWaiter {
+ public:
+  Aws::Utils::WaiterOutcome<Model::DescribeCertificateOutcome> WaitUntilCertificateValidated(
+      const Model::DescribeCertificateRequest& request) {
+    using OutcomeT = Model::DescribeCertificateOutcome;
+    using RequestT = Model::DescribeCertificateRequest;
+    Aws::Vector<Aws::UniquePtr<Aws::Utils::Acceptor<OutcomeT>>> acceptors;
+    acceptors.emplace_back(Aws::MakeUnique<Aws::Utils::PathAcceptor<OutcomeT>>(
+        "CertificateValidatedWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("SUCCESS"),
+        [](const Model::DescribeCertificateOutcome& outcome, const Aws::Utils::ExpectedValue& expected) -> bool {
+          if (!outcome.IsSuccess()) return false;
+          const auto& result = outcome.GetResult();
+          return std::all_of(result.GetCertificate().GetDomainValidationOptions().begin(),
+                             result.GetCertificate().GetDomainValidationOptions().end(), [&](const Model::DomainValidation& item) {
+                               return Model::DomainStatusMapper::GetNameForDomainStatus(item.GetValidationStatus()) ==
+                                      expected.get<Aws::String>();
+                             });
+        }));
+    acceptors.emplace_back(Aws::MakeUnique<Aws::Utils::PathAcceptor<OutcomeT>>(
+        "CertificateValidatedWaiter", Aws::Utils::WaiterState::RETRY, Aws::String("PENDING_VALIDATION"),
+        [](const Model::DescribeCertificateOutcome& outcome, const Aws::Utils::ExpectedValue& expected) -> bool {
+          if (!outcome.IsSuccess()) return false;
+          const auto& result = outcome.GetResult();
+          return std::any_of(result.GetCertificate().GetDomainValidationOptions().begin(),
+                             result.GetCertificate().GetDomainValidationOptions().end(), [&](const Model::DomainValidation& item) {
+                               return Model::DomainStatusMapper::GetNameForDomainStatus(item.GetValidationStatus()) ==
+                                      expected.get<Aws::String>();
+                             });
+        }));
+    acceptors.emplace_back(Aws::MakeUnique<Aws::Utils::PathAcceptor<OutcomeT>>(
+        "CertificateValidatedWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("FAILED"),
+        [](const Model::DescribeCertificateOutcome& outcome, const Aws::Utils::ExpectedValue& expected) -> bool {
+          if (!outcome.IsSuccess()) return false;
+          const auto& result = outcome.GetResult();
+          return Model::CertificateStatusMapper::GetNameForCertificateStatus(result.GetCertificate().GetStatus()) ==
+                 expected.get<Aws::String>();
+        }));
+    acceptors.emplace_back(Aws::MakeUnique<Aws::Utils::ErrorAcceptor<OutcomeT>>(
+        "CertificateValidatedWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("ResourceNotFoundException")));
+
+    auto operation = [this](const RequestT& req) { return static_cast<DerivedClient*>(this)->DescribeCertificate(req); };
+    Aws::Utils::Waiter<RequestT, OutcomeT> waiter(60, 2, std::move(acceptors), operation, "WaitUntilCertificateValidated");
+    return waiter.Wait(request);
+  }
+};
+}  // namespace ACM
+}  // namespace Aws