Documentation updates to reflect service rename - AWS IAM Identity Center (successor to AWS Single Sign-On)

RDS for Oracle supports Oracle Data Guard switchover and read replica backups.

Author: aws-sdk-cpp-automation

aws-cpp-sdk-core/include/aws/core/VersionConfig.h

@@ -3,7 +3,7 @@
  * SPDX-License-Identifier: Apache-2.0.
  */
 
-#define AWS_SDK_VERSION_STRING 1.9.330
+#define AWS_SDK_VERSION_STRING 1.9.331
 #define AWS_SDK_VERSION_MAJOR 1
 #define AWS_SDK_VERSION_MINOR 9
-#define AWS_SDK_VERSION_PATCH 330
+#define AWS_SDK_VERSION_PATCH 331

aws-cpp-sdk-rds/include/aws/rds/RDSClient.h

@@ -137,6 +137,7 @@
 #include <aws/rds/model/StopDBClusterResult.h>
 #include <aws/rds/model/StopDBInstanceResult.h>
 #include <aws/rds/model/StopDBInstanceAutomatedBackupsReplicationResult.h>
+#include <aws/rds/model/SwitchoverReadReplicaResult.h>
 #include <aws/core/NoResult.h>
 #include <aws/core/client/AsyncCallerContext.h>
 #include <aws/core/http/HttpTypes.h>
@@ -317,6 +318,7 @@ namespace Aws
         class StopDBClusterRequest;
         class StopDBInstanceRequest;
         class StopDBInstanceAutomatedBackupsReplicationRequest;
+        class SwitchoverReadReplicaRequest;
 
         typedef Aws::Utils::Outcome<Aws::NoResult, RDSError> AddRoleToDBClusterOutcome;
         typedef Aws::Utils::Outcome<Aws::NoResult, RDSError> AddRoleToDBInstanceOutcome;
@@ -454,6 +456,7 @@ namespace Aws
         typedef Aws::Utils::Outcome<StopDBClusterResult, RDSError> StopDBClusterOutcome;
         typedef Aws::Utils::Outcome<StopDBInstanceResult, RDSError> StopDBInstanceOutcome;
         typedef Aws::Utils::Outcome<StopDBInstanceAutomatedBackupsReplicationResult, RDSError> StopDBInstanceAutomatedBackupsReplicationOutcome;
+        typedef Aws::Utils::Outcome<SwitchoverReadReplicaResult, RDSError> SwitchoverReadReplicaOutcome;
 
         typedef std::future<AddRoleToDBClusterOutcome> AddRoleToDBClusterOutcomeCallable;
         typedef std::future<AddRoleToDBInstanceOutcome> AddRoleToDBInstanceOutcomeCallable;
@@ -591,6 +594,7 @@ namespace Aws
         typedef std::future<StopDBClusterOutcome> StopDBClusterOutcomeCallable;
         typedef std::future<StopDBInstanceOutcome> StopDBInstanceOutcomeCallable;
         typedef std::future<StopDBInstanceAutomatedBackupsReplicationOutcome> StopDBInstanceAutomatedBackupsReplicationOutcomeCallable;
+        typedef std::future<SwitchoverReadReplicaOutcome> SwitchoverReadReplicaOutcomeCallable;
     } // namespace Model
 
         class RDSClient;
@@ -731,6 +735,7 @@ namespace Aws
     typedef std::function<void(const RDSClient*, const Model::StopDBClusterRequest&, const Model::StopDBClusterOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > StopDBClusterResponseReceivedHandler;
     typedef std::function<void(const RDSClient*, const Model::StopDBInstanceRequest&, const Model::StopDBInstanceOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > StopDBInstanceResponseReceivedHandler;
     typedef std::function<void(const RDSClient*, const Model::StopDBInstanceAutomatedBackupsReplicationRequest&, const Model::StopDBInstanceAutomatedBackupsReplicationOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > StopDBInstanceAutomatedBackupsReplicationResponseReceivedHandler;
+    typedef std::function<void(const RDSClient*, const Model::SwitchoverReadReplicaRequest&, const Model::SwitchoverReadReplicaOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > SwitchoverReadReplicaResponseReceivedHandler;
 
         /**
      * <fullname>Amazon Relational Database Service</fullname> <p/> <p>Amazon
@@ -4026,6 +4031,25 @@ namespace Aws
          */
         virtual void StopDBInstanceAutomatedBackupsReplicationAsync(const Model::StopDBInstanceAutomatedBackupsReplicationRequest& request, const StopDBInstanceAutomatedBackupsReplicationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const;
 
+        /**
+         * <p>Switches over an Oracle standby database in an Oracle Data Guard environment,
+         * making it the new primary database. Issue this command in the AWS Region that
+         * hosts the current standby database.</p><p><h3>See Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/rds-2014-10-31/SwitchoverReadReplica">AWS
+         * API Reference</a></p>
+         */
+        virtual Model::SwitchoverReadReplicaOutcome SwitchoverReadReplica(const Model::SwitchoverReadReplicaRequest& request) const;
+
+        /**
+         * A Callable wrapper for SwitchoverReadReplica that returns a future to the operation so that it can be executed in parallel to other requests.
+         */
+        virtual Model::SwitchoverReadReplicaOutcomeCallable SwitchoverReadReplicaCallable(const Model::SwitchoverReadReplicaRequest& request) const;
+
+        /**
+         * An Async wrapper for SwitchoverReadReplica that queues the request into a thread executor and triggers associated callback when operation has finished.
+         */
+        virtual void SwitchoverReadReplicaAsync(const Model::SwitchoverReadReplicaRequest& request, const SwitchoverReadReplicaResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const;
+
 
         void OverrideEndpoint(const Aws::String& endpoint);
     private:
@@ -4166,6 +4190,7 @@ namespace Aws
         void StopDBClusterAsyncHelper(const Model::StopDBClusterRequest& request, const StopDBClusterResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const;
         void StopDBInstanceAsyncHelper(const Model::StopDBInstanceRequest& request, const StopDBInstanceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const;
         void StopDBInstanceAutomatedBackupsReplicationAsyncHelper(const Model::StopDBInstanceAutomatedBackupsReplicationRequest& request, const StopDBInstanceAutomatedBackupsReplicationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const;
+        void SwitchoverReadReplicaAsyncHelper(const Model::SwitchoverReadReplicaRequest& request, const SwitchoverReadReplicaResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const;
 
         Aws::String m_uri;
         Aws::String m_configScheme;

aws-cpp-sdk-rds/include/aws/rds/model/DBSnapshot.h

@@ -1243,6 +1243,85 @@ namespace Model
     inline DBSnapshot& WithOriginalSnapshotCreateTime(Aws::Utils::DateTime&& value) { SetOriginalSnapshotCreateTime(std::move(value)); return *this;}
 
 
+    /**
+     * <p>The timestamp of the most recent transaction applied to the database that
+     * you're backing up. Thus, if you restore a snapshot, SnapshotDatabaseTime is the
+     * most recent transaction in the restored DB instance. In contrast,
+     * originalSnapshotCreateTime specifies the system time that the snapshot
+     * completed.</p> <p>If you back up a read replica, you can determine the replica
+     * lag by comparing SnapshotDatabaseTime with originalSnapshotCreateTime. For
+     * example, if originalSnapshotCreateTime is two hours later than
+     * SnapshotDatabaseTime, then the replica lag is two hours. *** REVIEWERS 7/27:
+     * Switchover</p>
+     */
+    inline const Aws::Utils::DateTime& GetSnapshotDatabaseTime() const{ return m_snapshotDatabaseTime; }
+
+    /**
+     * <p>The timestamp of the most recent transaction applied to the database that
+     * you're backing up. Thus, if you restore a snapshot, SnapshotDatabaseTime is the
+     * most recent transaction in the restored DB instance. In contrast,
+     * originalSnapshotCreateTime specifies the system time that the snapshot
+     * completed.</p> <p>If you back up a read replica, you can determine the replica
+     * lag by comparing SnapshotDatabaseTime with originalSnapshotCreateTime. For
+     * example, if originalSnapshotCreateTime is two hours later than
+     * SnapshotDatabaseTime, then the replica lag is two hours. *** REVIEWERS 7/27:
+     * Switchover</p>
+     */
+    inline bool SnapshotDatabaseTimeHasBeenSet() const { return m_snapshotDatabaseTimeHasBeenSet; }
+
+    /**
+     * <p>The timestamp of the most recent transaction applied to the database that
+     * you're backing up. Thus, if you restore a snapshot, SnapshotDatabaseTime is the
+     * most recent transaction in the restored DB instance. In contrast,
+     * originalSnapshotCreateTime specifies the system time that the snapshot
+     * completed.</p> <p>If you back up a read replica, you can determine the replica
+     * lag by comparing SnapshotDatabaseTime with originalSnapshotCreateTime. For
+     * example, if originalSnapshotCreateTime is two hours later than
+     * SnapshotDatabaseTime, then the replica lag is two hours. *** REVIEWERS 7/27:
+     * Switchover</p>
+     */
+    inline void SetSnapshotDatabaseTime(const Aws::Utils::DateTime& value) { m_snapshotDatabaseTimeHasBeenSet = true; m_snapshotDatabaseTime = value; }
+
+    /**
+     * <p>The timestamp of the most recent transaction applied to the database that
+     * you're backing up. Thus, if you restore a snapshot, SnapshotDatabaseTime is the
+     * most recent transaction in the restored DB instance. In contrast,
+     * originalSnapshotCreateTime specifies the system time that the snapshot
+     * completed.</p> <p>If you back up a read replica, you can determine the replica
+     * lag by comparing SnapshotDatabaseTime with originalSnapshotCreateTime. For
+     * example, if originalSnapshotCreateTime is two hours later than
+     * SnapshotDatabaseTime, then the replica lag is two hours. *** REVIEWERS 7/27:
+     * Switchover</p>
+     */
+    inline void SetSnapshotDatabaseTime(Aws::Utils::DateTime&& value) { m_snapshotDatabaseTimeHasBeenSet = true; m_snapshotDatabaseTime = std::move(value); }
+
+    /**
+     * <p>The timestamp of the most recent transaction applied to the database that
+     * you're backing up. Thus, if you restore a snapshot, SnapshotDatabaseTime is the
+     * most recent transaction in the restored DB instance. In contrast,
+     * originalSnapshotCreateTime specifies the system time that the snapshot
+     * completed.</p> <p>If you back up a read replica, you can determine the replica
+     * lag by comparing SnapshotDatabaseTime with originalSnapshotCreateTime. For
+     * example, if originalSnapshotCreateTime is two hours later than
+     * SnapshotDatabaseTime, then the replica lag is two hours. *** REVIEWERS 7/27:
+     * Switchover</p>
+     */
+    inline DBSnapshot& WithSnapshotDatabaseTime(const Aws::Utils::DateTime& value) { SetSnapshotDatabaseTime(value); return *this;}
+
+    /**
+     * <p>The timestamp of the most recent transaction applied to the database that
+     * you're backing up. Thus, if you restore a snapshot, SnapshotDatabaseTime is the
+     * most recent transaction in the restored DB instance. In contrast,
+     * originalSnapshotCreateTime specifies the system time that the snapshot
+     * completed.</p> <p>If you back up a read replica, you can determine the replica
+     * lag by comparing SnapshotDatabaseTime with originalSnapshotCreateTime. For
+     * example, if originalSnapshotCreateTime is two hours later than
+     * SnapshotDatabaseTime, then the replica lag is two hours. *** REVIEWERS 7/27:
+     * Switchover</p>
+     */
+    inline DBSnapshot& WithSnapshotDatabaseTime(Aws::Utils::DateTime&& value) { SetSnapshotDatabaseTime(std::move(value)); return *this;}
+
+
     /**
      * <p>Specifies where manual snapshots are stored: Amazon Web Services Outposts or
      * the Amazon Web Services Region.</p>
@@ -1383,6 +1462,9 @@ namespace Model
     Aws::Utils::DateTime m_originalSnapshotCreateTime;
     bool m_originalSnapshotCreateTimeHasBeenSet;
 
+    Aws::Utils::DateTime m_snapshotDatabaseTime;
+    bool m_snapshotDatabaseTimeHasBeenSet;
+
     Aws::String m_snapshotTarget;
     bool m_snapshotTargetHasBeenSet;
   };

aws-cpp-sdk-rds/include/aws/rds/model/SwitchoverReadReplicaRequest.h

@@ -0,0 +1,103 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/rds/RDS_EXPORTS.h>
+#include <aws/rds/RDSRequest.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <utility>
+
+namespace Aws
+{
+namespace RDS
+{
+namespace Model
+{
+
+  /**
+   */
+  class AWS_RDS_API SwitchoverReadReplicaRequest : public RDSRequest
+  {
+  public:
+    SwitchoverReadReplicaRequest();
+
+    // Service request name is the Operation name which will send this request out,
+    // each operation should has unique request name, so that we can get operation's name from this request.
+    // Note: this is not true for response, multiple operations may have the same response name,
+    // so we can not get operation's name from response.
+    inline virtual const char* GetServiceRequestName() const override { return "SwitchoverReadReplica"; }
+
+    Aws::String SerializePayload() const override;
+
+  protected:
+    void DumpBodyToUrl(Aws::Http::URI& uri ) const override;
+
+  public:
+
+    /**
+     * <p>The DB instance identifier of the current standby database. This value is
+     * stored as a lowercase string.</p> <p>Constraints:</p> <ul> <li> <p>Must match
+     * the identifier of an existing Oracle read replica DB instance.</p> </li> </ul>
+     */
+    inline const Aws::String& GetDBInstanceIdentifier() const{ return m_dBInstanceIdentifier; }
+
+    /**
+     * <p>The DB instance identifier of the current standby database. This value is
+     * stored as a lowercase string.</p> <p>Constraints:</p> <ul> <li> <p>Must match
+     * the identifier of an existing Oracle read replica DB instance.</p> </li> </ul>
+     */
+    inline bool DBInstanceIdentifierHasBeenSet() const { return m_dBInstanceIdentifierHasBeenSet; }
+
+    /**
+     * <p>The DB instance identifier of the current standby database. This value is
+     * stored as a lowercase string.</p> <p>Constraints:</p> <ul> <li> <p>Must match
+     * the identifier of an existing Oracle read replica DB instance.</p> </li> </ul>
+     */
+    inline void SetDBInstanceIdentifier(const Aws::String& value) { m_dBInstanceIdentifierHasBeenSet = true; m_dBInstanceIdentifier = value; }
+
+    /**
+     * <p>The DB instance identifier of the current standby database. This value is
+     * stored as a lowercase string.</p> <p>Constraints:</p> <ul> <li> <p>Must match
+     * the identifier of an existing Oracle read replica DB instance.</p> </li> </ul>
+     */
+    inline void SetDBInstanceIdentifier(Aws::String&& value) { m_dBInstanceIdentifierHasBeenSet = true; m_dBInstanceIdentifier = std::move(value); }
+
+    /**
+     * <p>The DB instance identifier of the current standby database. This value is
+     * stored as a lowercase string.</p> <p>Constraints:</p> <ul> <li> <p>Must match
+     * the identifier of an existing Oracle read replica DB instance.</p> </li> </ul>
+     */
+    inline void SetDBInstanceIdentifier(const char* value) { m_dBInstanceIdentifierHasBeenSet = true; m_dBInstanceIdentifier.assign(value); }
+
+    /**
+     * <p>The DB instance identifier of the current standby database. This value is
+     * stored as a lowercase string.</p> <p>Constraints:</p> <ul> <li> <p>Must match
+     * the identifier of an existing Oracle read replica DB instance.</p> </li> </ul>
+     */
+    inline SwitchoverReadReplicaRequest& WithDBInstanceIdentifier(const Aws::String& value) { SetDBInstanceIdentifier(value); return *this;}
+
+    /**
+     * <p>The DB instance identifier of the current standby database. This value is
+     * stored as a lowercase string.</p> <p>Constraints:</p> <ul> <li> <p>Must match
+     * the identifier of an existing Oracle read replica DB instance.</p> </li> </ul>
+     */
+    inline SwitchoverReadReplicaRequest& WithDBInstanceIdentifier(Aws::String&& value) { SetDBInstanceIdentifier(std::move(value)); return *this;}
+
+    /**
+     * <p>The DB instance identifier of the current standby database. This value is
+     * stored as a lowercase string.</p> <p>Constraints:</p> <ul> <li> <p>Must match
+     * the identifier of an existing Oracle read replica DB instance.</p> </li> </ul>
+     */
+    inline SwitchoverReadReplicaRequest& WithDBInstanceIdentifier(const char* value) { SetDBInstanceIdentifier(value); return *this;}
+
+  private:
+
+    Aws::String m_dBInstanceIdentifier;
+    bool m_dBInstanceIdentifierHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace RDS
+} // namespace Aws

aws-cpp-sdk-rds/include/aws/rds/model/SwitchoverReadReplicaResult.h

@@ -0,0 +1,76 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/rds/RDS_EXPORTS.h>
+#include <aws/rds/model/DBInstance.h>
+#include <aws/rds/model/ResponseMetadata.h>
+#include <utility>
+
+namespace Aws
+{
+template<typename RESULT_TYPE>
+class AmazonWebServiceResult;
+
+namespace Utils
+{
+namespace Xml
+{
+  class XmlDocument;
+} // namespace Xml
+} // namespace Utils
+namespace RDS
+{
+namespace Model
+{
+  class AWS_RDS_API SwitchoverReadReplicaResult
+  {
+  public:
+    SwitchoverReadReplicaResult();
+    SwitchoverReadReplicaResult(const Aws::AmazonWebServiceResult<Aws::Utils::Xml::XmlDocument>& result);
+    SwitchoverReadReplicaResult& operator=(const Aws::AmazonWebServiceResult<Aws::Utils::Xml::XmlDocument>& result);
+
+
+    
+    inline const DBInstance& GetDBInstance() const{ return m_dBInstance; }
+
+    
+    inline void SetDBInstance(const DBInstance& value) { m_dBInstance = value; }
+
+    
+    inline void SetDBInstance(DBInstance&& value) { m_dBInstance = std::move(value); }
+
+    
+    inline SwitchoverReadReplicaResult& WithDBInstance(const DBInstance& value) { SetDBInstance(value); return *this;}
+
+    
+    inline SwitchoverReadReplicaResult& WithDBInstance(DBInstance&& value) { SetDBInstance(std::move(value)); return *this;}
+
+
+    
+    inline const ResponseMetadata& GetResponseMetadata() const{ return m_responseMetadata; }
+
+    
+    inline void SetResponseMetadata(const ResponseMetadata& value) { m_responseMetadata = value; }
+
+    
+    inline void SetResponseMetadata(ResponseMetadata&& value) { m_responseMetadata = std::move(value); }
+
+    
+    inline SwitchoverReadReplicaResult& WithResponseMetadata(const ResponseMetadata& value) { SetResponseMetadata(value); return *this;}
+
+    
+    inline SwitchoverReadReplicaResult& WithResponseMetadata(ResponseMetadata&& value) { SetResponseMetadata(std::move(value)); return *this;}
+
+  private:
+
+    DBInstance m_dBInstance;
+
+    ResponseMetadata m_responseMetadata;
+  };
+
+} // namespace Model
+} // namespace RDS
+} // namespace Aws