feat(client-rds): This release adds the "ModifyActivityStream" API with support for audit policy state locking and unlocking.

Author: awstools

clients/client-rds/src/RDS.ts

@@ -441,6 +441,11 @@ import {
   ListTagsForResourceCommandInput,
   ListTagsForResourceCommandOutput,
 } from "./commands/ListTagsForResourceCommand";
+import {
+  ModifyActivityStreamCommand,
+  ModifyActivityStreamCommandInput,
+  ModifyActivityStreamCommandOutput,
+} from "./commands/ModifyActivityStreamCommand";
 import {
   ModifyCertificatesCommand,
   ModifyCertificatesCommandInput,
@@ -3982,6 +3987,42 @@ export class RDS extends RDSClient {
     }
   }
 
+  /**
+   * <p>Changes the audit policy state of a database activity stream to either locked (default) or unlocked. A locked policy is read-only,
+   *             whereas an unlocked policy is read/write. If your activity stream is started and locked, you can unlock it, customize your audit policy,
+   *             and then lock your activity stream. Restarting the activity stream isn't required. For more information, see <a href="https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/DBActivityStreams.Modifying.html"> Modifying a database activity stream</a> in the
+   *                 <i>Amazon RDS User Guide</i>. </p>
+   *         <p>This operation is supported for RDS for Oracle only.</p>
+   */
+  public modifyActivityStream(
+    args: ModifyActivityStreamCommandInput,
+    options?: __HttpHandlerOptions
+  ): Promise<ModifyActivityStreamCommandOutput>;
+  public modifyActivityStream(
+    args: ModifyActivityStreamCommandInput,
+    cb: (err: any, data?: ModifyActivityStreamCommandOutput) => void
+  ): void;
+  public modifyActivityStream(
+    args: ModifyActivityStreamCommandInput,
+    options: __HttpHandlerOptions,
+    cb: (err: any, data?: ModifyActivityStreamCommandOutput) => void
+  ): void;
+  public modifyActivityStream(
+    args: ModifyActivityStreamCommandInput,
+    optionsOrCb?: __HttpHandlerOptions | ((err: any, data?: ModifyActivityStreamCommandOutput) => void),
+    cb?: (err: any, data?: ModifyActivityStreamCommandOutput) => void
+  ): Promise<ModifyActivityStreamCommandOutput> | void {
+    const command = new ModifyActivityStreamCommand(args);
+    if (typeof optionsOrCb === "function") {
+      this.send(command, optionsOrCb);
+    } else if (typeof cb === "function") {
+      if (typeof optionsOrCb !== "object") throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+      this.send(command, optionsOrCb || {}, cb);
+    } else {
+      return this.send(command, optionsOrCb);
+    }
+  }
+
   /**
    * <p>Override the system-default Secure Sockets Layer/Transport Layer Security (SSL/TLS)
    *           certificate for Amazon RDS for new DB instances, or remove the override.</p>

clients/client-rds/src/RDSClient.ts

@@ -342,6 +342,10 @@ import {
   ListTagsForResourceCommandInput,
   ListTagsForResourceCommandOutput,
 } from "./commands/ListTagsForResourceCommand";
+import {
+  ModifyActivityStreamCommandInput,
+  ModifyActivityStreamCommandOutput,
+} from "./commands/ModifyActivityStreamCommand";
 import { ModifyCertificatesCommandInput, ModifyCertificatesCommandOutput } from "./commands/ModifyCertificatesCommand";
 import {
   ModifyCurrentDBClusterCapacityCommandInput,
@@ -576,6 +580,7 @@ export type ServiceInputTypes =
   | FailoverDBClusterCommandInput
   | FailoverGlobalClusterCommandInput
   | ListTagsForResourceCommandInput
+  | ModifyActivityStreamCommandInput
   | ModifyCertificatesCommandInput
   | ModifyCurrentDBClusterCapacityCommandInput
   | ModifyCustomDBEngineVersionCommandInput
@@ -713,6 +718,7 @@ export type ServiceOutputTypes =
   | FailoverDBClusterCommandOutput
   | FailoverGlobalClusterCommandOutput
   | ListTagsForResourceCommandOutput
+  | ModifyActivityStreamCommandOutput
   | ModifyCertificatesCommandOutput
   | ModifyCurrentDBClusterCapacityCommandOutput
   | ModifyCustomDBEngineVersionCommandOutput

clients/client-rds/src/commands/ModifyActivityStreamCommand.ts

@@ -0,0 +1,100 @@
+// smithy-typescript generated code
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { HttpRequest as __HttpRequest, HttpResponse as __HttpResponse } from "@aws-sdk/protocol-http";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import {
+  FinalizeHandlerArguments,
+  Handler,
+  HandlerExecutionContext,
+  HttpHandlerOptions as __HttpHandlerOptions,
+  MetadataBearer as __MetadataBearer,
+  MiddlewareStack,
+  SerdeContext as __SerdeContext,
+} from "@aws-sdk/types";
+
+import { ModifyActivityStreamRequest, ModifyActivityStreamResponse } from "../models/models_1";
+import {
+  deserializeAws_queryModifyActivityStreamCommand,
+  serializeAws_queryModifyActivityStreamCommand,
+} from "../protocols/Aws_query";
+import { RDSClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../RDSClient";
+
+export interface ModifyActivityStreamCommandInput extends ModifyActivityStreamRequest {}
+export interface ModifyActivityStreamCommandOutput extends ModifyActivityStreamResponse, __MetadataBearer {}
+
+/**
+ * <p>Changes the audit policy state of a database activity stream to either locked (default) or unlocked. A locked policy is read-only,
+ *             whereas an unlocked policy is read/write. If your activity stream is started and locked, you can unlock it, customize your audit policy,
+ *             and then lock your activity stream. Restarting the activity stream isn't required. For more information, see <a href="https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/DBActivityStreams.Modifying.html"> Modifying a database activity stream</a> in the
+ *                 <i>Amazon RDS User Guide</i>. </p>
+ *         <p>This operation is supported for RDS for Oracle only.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { RDSClient, ModifyActivityStreamCommand } from "@aws-sdk/client-rds"; // ES Modules import
+ * // const { RDSClient, ModifyActivityStreamCommand } = require("@aws-sdk/client-rds"); // CommonJS import
+ * const client = new RDSClient(config);
+ * const command = new ModifyActivityStreamCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link ModifyActivityStreamCommandInput} for command's `input` shape.
+ * @see {@link ModifyActivityStreamCommandOutput} for command's `response` shape.
+ * @see {@link RDSClientResolvedConfig | config} for RDSClient's `config` shape.
+ *
+ */
+export class ModifyActivityStreamCommand extends $Command<
+  ModifyActivityStreamCommandInput,
+  ModifyActivityStreamCommandOutput,
+  RDSClientResolvedConfig
+> {
+  // Start section: command_properties
+  // End section: command_properties
+
+  constructor(readonly input: ModifyActivityStreamCommandInput) {
+    // Start section: command_constructor
+    super();
+    // End section: command_constructor
+  }
+
+  /**
+   * @internal
+   */
+  resolveMiddleware(
+    clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>,
+    configuration: RDSClientResolvedConfig,
+    options?: __HttpHandlerOptions
+  ): Handler<ModifyActivityStreamCommandInput, ModifyActivityStreamCommandOutput> {
+    this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+
+    const stack = clientStack.concat(this.middlewareStack);
+
+    const { logger } = configuration;
+    const clientName = "RDSClient";
+    const commandName = "ModifyActivityStreamCommand";
+    const handlerExecutionContext: HandlerExecutionContext = {
+      logger,
+      clientName,
+      commandName,
+      inputFilterSensitiveLog: ModifyActivityStreamRequest.filterSensitiveLog,
+      outputFilterSensitiveLog: ModifyActivityStreamResponse.filterSensitiveLog,
+    };
+    const { requestHandler } = configuration;
+    return stack.resolve(
+      (request: FinalizeHandlerArguments<any>) =>
+        requestHandler.handle(request.request as __HttpRequest, options || {}),
+      handlerExecutionContext
+    );
+  }
+
+  private serialize(input: ModifyActivityStreamCommandInput, context: __SerdeContext): Promise<__HttpRequest> {
+    return serializeAws_queryModifyActivityStreamCommand(input, context);
+  }
+
+  private deserialize(output: __HttpResponse, context: __SerdeContext): Promise<ModifyActivityStreamCommandOutput> {
+    return deserializeAws_queryModifyActivityStreamCommand(output, context);
+  }
+
+  // Start section: command_body_extra
+  // End section: command_body_extra
+}

clients/client-rds/src/commands/index.ts

@@ -87,6 +87,7 @@ export * from "./DownloadDBLogFilePortionCommand";
 export * from "./FailoverDBClusterCommand";
 export * from "./FailoverGlobalClusterCommand";
 export * from "./ListTagsForResourceCommand";
+export * from "./ModifyActivityStreamCommand";
 export * from "./ModifyCertificatesCommand";
 export * from "./ModifyCurrentDBClusterCapacityCommand";
 export * from "./ModifyCustomDBEngineVersionCommand";

clients/client-rds/src/models/models_0.ts

@@ -163,6 +163,13 @@ export namespace AccountAttributesMessage {
 
 export type ActivityStreamMode = "async" | "sync";
 
+export enum ActivityStreamPolicyStatus {
+  locked = "locked",
+  locking_policy = "locking-policy",
+  unlocked = "unlocked",
+  unlocking_policy = "unlocking-policy",
+}
+
 export type ActivityStreamStatus = "started" | "starting" | "stopped" | "stopping";
 
 export interface AddRoleToDBClusterMessage {
@@ -7837,6 +7844,11 @@ export interface DBInstance {
    *          </p>
    */
   NetworkType?: string;
+
+  /**
+   * <p>The status of the policy state of the activity stream.</p>
+   */
+  ActivityStreamPolicyStatus?: ActivityStreamPolicyStatus | string;
 }
 
 export namespace DBInstance {
@@ -8764,7 +8776,7 @@ export interface CreateDBProxyRequest {
   /**
    * <p>The kinds of databases that the proxy can connect to.
    *           This value determines which database network protocol the proxy recognizes when it interprets
-   *         network traffic to and from the database. For Aurora MySQL, RDS for MariaDB, and RDS for MySQL databases, specify <code>MYSQL</code>.
+   *         network traffic to and from the database. For Aurora MySQL and RDS for MySQL databases, specify <code>MYSQL</code>.
    *         For Aurora PostgreSQL and RDS for PostgreSQL databases, specify <code>POSTGRESQL</code>.</p>
    */
   EngineFamily: EngineFamily | string | undefined;
@@ -8902,8 +8914,8 @@ export interface DBProxy {
 
   /**
    * <p>The kinds of databases that the proxy can connect to. This value determines which database network protocol
-   *         the proxy recognizes when it interprets network traffic to and from the database. <code>MYSQL</code> supports Aurora MySQL,
-   *         RDS for MariaDB, and RDS for MySQL databases. <code>POSTGRESQL</code> supports Aurora PostgreSQL and RDS for PostgreSQL databases.</p>
+   *         the proxy recognizes when it interprets network traffic to and from the database. <code>MYSQL</code> supports Aurora MySQL
+   *         and RDS for MySQL databases. <code>POSTGRESQL</code> supports Aurora PostgreSQL and RDS for PostgreSQL databases.</p>
    */
   EngineFamily?: string;
 
@@ -13704,38 +13716,3 @@ export namespace DescribeDBSnapshotAttributesMessage {
     ...obj,
   });
 }
-
-/**
- * <p>Contains the name and values of a manual DB snapshot attribute</p>
- *         <p>Manual DB snapshot attributes are used to authorize other Amazon Web Services accounts
- *     to restore a manual DB snapshot. For more information, see the <code>ModifyDBSnapshotAttribute</code>
- *     API.</p>
- */
-export interface DBSnapshotAttribute {
-  /**
-   * <p>The name of the manual DB snapshot attribute.</p>
-   *         <p>The attribute named <code>restore</code> refers to the list of Amazon Web Services accounts that
-   *           have permission to copy or restore the manual DB cluster snapshot. For more information,
-   *           see the <code>ModifyDBSnapshotAttribute</code>
-   *           API action.</p>
-   */
-  AttributeName?: string;
-
-  /**
-   * <p>The value or values for the manual DB snapshot attribute.</p>
-   *         <p>If the <code>AttributeName</code> field is set to <code>restore</code>, then this element
-   *       returns a list of IDs of the Amazon Web Services accounts that are authorized to copy or restore the manual
-   *       DB snapshot. If a value of <code>all</code> is in the list, then the manual DB snapshot
-   *       is public and available for any Amazon Web Services account to copy or restore.</p>
-   */
-  AttributeValues?: string[];
-}
-
-export namespace DBSnapshotAttribute {
-  /**
-   * @internal
-   */
-  export const filterSensitiveLog = (obj: DBSnapshotAttribute): any => ({
-    ...obj,
-  });
-}