apache-airflow-providers-amazon 9.5.0rc1__py3-none-any.whl → 9.5.0rc3__py3-none-any.whl

airflow/providers/amazon/aws/operators/ec2.py

@@ -18,21 +18,22 @@
 from __future__ import annotations
 
 from collections.abc import Sequence
-from typing import TYPE_CHECKING
+from typing import TYPE_CHECKING, Any
 
 from airflow.exceptions import AirflowException
-from airflow.models import BaseOperator
 from airflow.providers.amazon.aws.hooks.ec2 import EC2Hook
 from airflow.providers.amazon.aws.links.ec2 import (
     EC2InstanceDashboardLink,
     EC2InstanceLink,
 )
+from airflow.providers.amazon.aws.operators.base_aws import AwsBaseOperator
+from airflow.providers.amazon.aws.utils.mixins import aws_template_fields
 
 if TYPE_CHECKING:
     from airflow.utils.context import Context
 
 
-class EC2StartInstanceOperator(BaseOperator):
+class EC2StartInstanceOperator(AwsBaseOperator[EC2Hook]):
     """
     Start AWS EC2 instance using boto3.
 
@@ -41,18 +42,21 @@ class EC2StartInstanceOperator(BaseOperator):
         :ref:`howto/operator:EC2StartInstanceOperator`
 
     :param instance_id: id of the AWS EC2 instance
-    :param aws_conn_id: The Airflow connection used for AWS credentials.
-        If this is None or empty then the default boto3 behaviour is used. If
+        :param aws_conn_id: The Airflow connection used for AWS credentials.
+        If this is ``None`` or empty then the default boto3 behaviour is used. If
         running Airflow in a distributed manner and aws_conn_id is None or
         empty, then default boto3 configuration would be used (and must be
         maintained on each worker node).
-    :param region_name: (optional) aws region name associated with the client
+    :param region_name: AWS region_name. If not specified then the default boto3 behaviour is used.
+    :param verify: Whether or not to verify SSL certificates. See:
+        https://boto3.amazonaws.com/v1/documentation/api/latest/reference/core/session.html
     :param check_interval: time in seconds that the job should wait in
         between each instance state checks until operation is completed
     """
 
+    aws_hook_class = EC2Hook
     operator_extra_links = (EC2InstanceLink(),)
-    template_fields: Sequence[str] = ("instance_id", "region_name")
+    template_fields: Sequence[str] = aws_template_fields("instance_id", "region_name")
     ui_color = "#eeaa11"
     ui_fgcolor = "#ffffff"
 
@@ -60,37 +64,32 @@ class EC2StartInstanceOperator(BaseOperator):
         self,
         *,
         instance_id: str,
-        aws_conn_id: str | None = "aws_default",
-        region_name: str | None = None,
         check_interval: float = 15,
         **kwargs,
     ):
         super().__init__(**kwargs)
         self.instance_id = instance_id
-        self.aws_conn_id = aws_conn_id
-        self.region_name = region_name
         self.check_interval = check_interval
 
     def execute(self, context: Context):
-        ec2_hook = EC2Hook(aws_conn_id=self.aws_conn_id, region_name=self.region_name)
         self.log.info("Starting EC2 instance %s", self.instance_id)
-        instance = ec2_hook.get_instance(instance_id=self.instance_id)
+        instance = self.hook.get_instance(instance_id=self.instance_id)
         instance.start()
         EC2InstanceLink.persist(
             context=context,
             operator=self,
-            aws_partition=ec2_hook.conn_partition,
+            aws_partition=self.hook.conn_partition,
             instance_id=self.instance_id,
-            region_name=ec2_hook.conn_region_name,
+            region_name=self.hook.conn_region_name,
         )
-        ec2_hook.wait_for_state(
+        self.hook.wait_for_state(
             instance_id=self.instance_id,
             target_state="running",
             check_interval=self.check_interval,
         )
 
 
-class EC2StopInstanceOperator(BaseOperator):
+class EC2StopInstanceOperator(AwsBaseOperator[EC2Hook]):
     """
     Stop AWS EC2 instance using boto3.
 
@@ -100,17 +99,20 @@ class EC2StopInstanceOperator(BaseOperator):
 
     :param instance_id: id of the AWS EC2 instance
     :param aws_conn_id: The Airflow connection used for AWS credentials.
-        If this is None or empty then the default boto3 behaviour is used. If
+        If this is ``None`` or empty then the default boto3 behaviour is used. If
         running Airflow in a distributed manner and aws_conn_id is None or
         empty, then default boto3 configuration would be used (and must be
         maintained on each worker node).
-    :param region_name: (optional) aws region name associated with the client
+    :param region_name: AWS region_name. If not specified then the default boto3 behaviour is used.
+    :param verify: Whether or not to verify SSL certificates. See:
+        https://boto3.amazonaws.com/v1/documentation/api/latest/reference/core/session.html
     :param check_interval: time in seconds that the job should wait in
         between each instance state checks until operation is completed
     """
 
+    aws_hook_class = EC2Hook
     operator_extra_links = (EC2InstanceLink(),)
-    template_fields: Sequence[str] = ("instance_id", "region_name")
+    template_fields: Sequence[str] = aws_template_fields("instance_id", "region_name")
     ui_color = "#eeaa11"
     ui_fgcolor = "#ffffff"
 
@@ -118,38 +120,33 @@ class EC2StopInstanceOperator(BaseOperator):
         self,
         *,
         instance_id: str,
-        aws_conn_id: str | None = "aws_default",
-        region_name: str | None = None,
         check_interval: float = 15,
         **kwargs,
     ):
         super().__init__(**kwargs)
         self.instance_id = instance_id
-        self.aws_conn_id = aws_conn_id
-        self.region_name = region_name
         self.check_interval = check_interval
 
     def execute(self, context: Context):
-        ec2_hook = EC2Hook(aws_conn_id=self.aws_conn_id, region_name=self.region_name)
         self.log.info("Stopping EC2 instance %s", self.instance_id)
-        instance = ec2_hook.get_instance(instance_id=self.instance_id)
+        instance = self.hook.get_instance(instance_id=self.instance_id)
         EC2InstanceLink.persist(
             context=context,
             operator=self,
-            aws_partition=ec2_hook.conn_partition,
+            aws_partition=self.hook.conn_partition,
             instance_id=self.instance_id,
-            region_name=ec2_hook.conn_region_name,
+            region_name=self.hook.conn_region_name,
         )
         instance.stop()
 
-        ec2_hook.wait_for_state(
+        self.hook.wait_for_state(
             instance_id=self.instance_id,
             target_state="stopped",
             check_interval=self.check_interval,
         )
 
 
-class EC2CreateInstanceOperator(BaseOperator):
+class EC2CreateInstanceOperator(AwsBaseOperator[EC2Hook]):
     """
     Create and start a specified number of EC2 Instances using boto3.
 
@@ -161,11 +158,13 @@ class EC2CreateInstanceOperator(BaseOperator):
     :param max_count: Maximum number of instances to launch. Defaults to 1.
     :param min_count: Minimum number of instances to launch. Defaults to 1.
     :param aws_conn_id: The Airflow connection used for AWS credentials.
-        If this is None or empty then the default boto3 behaviour is used. If
+        If this is ``None`` or empty then the default boto3 behaviour is used. If
         running Airflow in a distributed manner and aws_conn_id is None or
         empty, then default boto3 configuration would be used (and must be
         maintained on each worker node).
-    :param region_name: AWS region name associated with the client.
+    :param region_name: AWS region_name. If not specified then the default boto3 behaviour is used.
+    :param verify: Whether or not to verify SSL certificates. See:
+        https://boto3.amazonaws.com/v1/documentation/api/latest/reference/core/session.html
     :param poll_interval: Number of seconds to wait before attempting to
         check state of instance. Only used if wait_for_completion is True. Default is 20.
     :param max_attempts: Maximum number of attempts when checking state of instance.
@@ -175,8 +174,10 @@ class EC2CreateInstanceOperator(BaseOperator):
         in the `running` state before returning.
     """
 
+    aws_hook_class = EC2Hook
+
     operator_extra_links = (EC2InstanceDashboardLink(),)
-    template_fields: Sequence[str] = (
+    template_fields: Sequence[str] = aws_template_fields(
         "image_id",
         "max_count",
         "min_count",
@@ -191,8 +192,6 @@ class EC2CreateInstanceOperator(BaseOperator):
         image_id: str,
         max_count: int = 1,
         min_count: int = 1,
-        aws_conn_id: str | None = "aws_default",
-        region_name: str | None = None,
         poll_interval: int = 20,
         max_attempts: int = 20,
         config: dict | None = None,
@@ -203,16 +202,17 @@ class EC2CreateInstanceOperator(BaseOperator):
         self.image_id = image_id
         self.max_count = max_count
         self.min_count = min_count
-        self.aws_conn_id = aws_conn_id
-        self.region_name = region_name
         self.poll_interval = poll_interval
         self.max_attempts = max_attempts
         self.config = config or {}
         self.wait_for_completion = wait_for_completion
 
+    @property
+    def _hook_parameters(self) -> dict[str, Any]:
+        return {**super()._hook_parameters, "api_type": "client_type"}
+
     def execute(self, context: Context):
-        ec2_hook = EC2Hook(aws_conn_id=self.aws_conn_id, region_name=self.region_name, api_type="client_type")
-        instances = ec2_hook.conn.run_instances(
+        instances = self.hook.conn.run_instances(
             ImageId=self.image_id,
             MinCount=self.min_count,
             MaxCount=self.max_count,
@@ -225,15 +225,15 @@ class EC2CreateInstanceOperator(BaseOperator):
         EC2InstanceDashboardLink.persist(
             context=context,
             operator=self,
-            region_name=ec2_hook.conn_region_name,
-            aws_partition=ec2_hook.conn_partition,
+            region_name=self.hook.conn_region_name,
+            aws_partition=self.hook.conn_partition,
             instance_ids=EC2InstanceDashboardLink.format_instance_id_filter(instance_ids),
         )
         for instance_id in instance_ids:
             self.log.info("Created EC2 instance %s", instance_id)
 
             if self.wait_for_completion:
-                ec2_hook.get_waiter("instance_running").wait(
+                self.hook.get_waiter("instance_running").wait(
                     InstanceIds=[instance_id],
                     WaiterConfig={
                         "Delay": self.poll_interval,
@@ -249,16 +249,16 @@ class EC2CreateInstanceOperator(BaseOperator):
 
         if instance_ids:
             self.log.info("on_kill: Terminating instance/s %s", ", ".join(instance_ids))
-            ec2_hook = EC2Hook(
+            """ ec2_hook = EC2Hook(
                 aws_conn_id=self.aws_conn_id,
                 region_name=self.region_name,
                 api_type="client_type",
-            )
-            ec2_hook.conn.terminate_instances(InstanceIds=instance_ids)
+            ) """
+            self.hook.terminate_instances(instance_ids=instance_ids)
         super().on_kill()
 
 
-class EC2TerminateInstanceOperator(BaseOperator):
+class EC2TerminateInstanceOperator(AwsBaseOperator[EC2Hook]):
     """
     Terminate EC2 Instances using boto3.
 
@@ -268,11 +268,13 @@ class EC2TerminateInstanceOperator(BaseOperator):
 
     :param instance_id: ID of the instance to be terminated.
     :param aws_conn_id: The Airflow connection used for AWS credentials.
-        If this is None or empty then the default boto3 behaviour is used. If
+        If this is ``None`` or empty then the default boto3 behaviour is used. If
         running Airflow in a distributed manner and aws_conn_id is None or
         empty, then default boto3 configuration would be used (and must be
         maintained on each worker node).
-    :param region_name: AWS region name associated with the client.
+    :param region_name: AWS region_name. If not specified then the default boto3 behaviour is used.
+    :param verify: Whether or not to verify SSL certificates. See:
+        https://boto3.amazonaws.com/v1/documentation/api/latest/reference/core/session.html
     :param poll_interval: Number of seconds to wait before attempting to
         check state of instance. Only used if wait_for_completion is True. Default is 20.
     :param max_attempts: Maximum number of attempts when checking state of instance.
@@ -281,13 +283,14 @@ class EC2TerminateInstanceOperator(BaseOperator):
         in the `terminated` state before returning.
     """
 
-    template_fields: Sequence[str] = ("instance_ids", "region_name", "aws_conn_id", "wait_for_completion")
+    aws_hook_class = EC2Hook
+    template_fields: Sequence[str] = aws_template_fields(
+        "instance_ids", "region_name", "aws_conn_id", "wait_for_completion"
+    )
 
     def __init__(
         self,
         instance_ids: str | list[str],
-        aws_conn_id: str | None = "aws_default",
-        region_name: str | None = None,
         poll_interval: int = 20,
         max_attempts: int = 20,
         wait_for_completion: bool = False,
@@ -295,22 +298,23 @@ class EC2TerminateInstanceOperator(BaseOperator):
     ):
         super().__init__(**kwargs)
         self.instance_ids = instance_ids
-        self.aws_conn_id = aws_conn_id
-        self.region_name = region_name
         self.poll_interval = poll_interval
         self.max_attempts = max_attempts
         self.wait_for_completion = wait_for_completion
 
+    @property
+    def _hook_parameters(self) -> dict[str, Any]:
+        return {**super()._hook_parameters, "api_type": "client_type"}
+
     def execute(self, context: Context):
         if isinstance(self.instance_ids, str):
             self.instance_ids = [self.instance_ids]
-        ec2_hook = EC2Hook(aws_conn_id=self.aws_conn_id, region_name=self.region_name, api_type="client_type")
-        ec2_hook.conn.terminate_instances(InstanceIds=self.instance_ids)
+        self.hook.conn.terminate_instances(InstanceIds=self.instance_ids)
 
         for instance_id in self.instance_ids:
             self.log.info("Terminating EC2 instance %s", instance_id)
             if self.wait_for_completion:
-                ec2_hook.get_waiter("instance_terminated").wait(
+                self.hook.get_waiter("instance_terminated").wait(
                     InstanceIds=[instance_id],
                     WaiterConfig={
                         "Delay": self.poll_interval,
@@ -319,7 +323,7 @@ class EC2TerminateInstanceOperator(BaseOperator):
                 )
 
 
-class EC2RebootInstanceOperator(BaseOperator):
+class EC2RebootInstanceOperator(AwsBaseOperator[EC2Hook]):
     """
     Reboot Amazon EC2 instances.
 
@@ -329,11 +333,13 @@ class EC2RebootInstanceOperator(BaseOperator):
 
     :param instance_ids: ID of the instance(s) to be rebooted.
     :param aws_conn_id: The Airflow connection used for AWS credentials.
-        If this is None or empty then the default boto3 behaviour is used. If
+        If this is ``None`` or empty then the default boto3 behaviour is used. If
         running Airflow in a distributed manner and aws_conn_id is None or
         empty, then default boto3 configuration would be used (and must be
         maintained on each worker node).
-    :param region_name: AWS region name associated with the client.
+    :param region_name: AWS region_name. If not specified then the default boto3 behaviour is used.
+    :param verify: Whether or not to verify SSL certificates. See:
+        https://boto3.amazonaws.com/v1/documentation/api/latest/reference/core/session.html
     :param poll_interval: Number of seconds to wait before attempting to
         check state of instance. Only used if wait_for_completion is True. Default is 20.
     :param max_attempts: Maximum number of attempts when checking state of instance.
@@ -342,8 +348,9 @@ class EC2RebootInstanceOperator(BaseOperator):
         in the `running` state before returning.
     """
 
+    aws_hook_class = EC2Hook
     operator_extra_links = (EC2InstanceDashboardLink(),)
-    template_fields: Sequence[str] = ("instance_ids", "region_name")
+    template_fields: Sequence[str] = aws_template_fields("instance_ids", "region_name")
     ui_color = "#eeaa11"
     ui_fgcolor = "#ffffff"
 
@@ -351,8 +358,6 @@ class EC2RebootInstanceOperator(BaseOperator):
         self,
         *,
         instance_ids: str | list[str],
-        aws_conn_id: str | None = "aws_default",
-        region_name: str | None = None,
         poll_interval: int = 20,
         max_attempts: int = 20,
         wait_for_completion: bool = False,
@@ -360,29 +365,30 @@ class EC2RebootInstanceOperator(BaseOperator):
     ):
         super().__init__(**kwargs)
         self.instance_ids = instance_ids
-        self.aws_conn_id = aws_conn_id
-        self.region_name = region_name
         self.poll_interval = poll_interval
         self.max_attempts = max_attempts
         self.wait_for_completion = wait_for_completion
 
+    @property
+    def _hook_parameters(self) -> dict[str, Any]:
+        return {**super()._hook_parameters, "api_type": "client_type"}
+
     def execute(self, context: Context):
         if isinstance(self.instance_ids, str):
             self.instance_ids = [self.instance_ids]
-        ec2_hook = EC2Hook(aws_conn_id=self.aws_conn_id, region_name=self.region_name, api_type="client_type")
         self.log.info("Rebooting EC2 instances %s", ", ".join(self.instance_ids))
-        ec2_hook.conn.reboot_instances(InstanceIds=self.instance_ids)
+        self.hook.conn.reboot_instances(InstanceIds=self.instance_ids)
 
         # Console link is for EC2 dashboard list, not individual instances
         EC2InstanceDashboardLink.persist(
             context=context,
             operator=self,
-            region_name=ec2_hook.conn_region_name,
-            aws_partition=ec2_hook.conn_partition,
+            region_name=self.hook.conn_region_name,
+            aws_partition=self.hook.conn_partition,
             instance_ids=EC2InstanceDashboardLink.format_instance_id_filter(self.instance_ids),
         )
         if self.wait_for_completion:
-            ec2_hook.get_waiter("instance_running").wait(
+            self.hook.get_waiter("instance_running").wait(
                 InstanceIds=self.instance_ids,
                 WaiterConfig={
                     "Delay": self.poll_interval,
@@ -391,7 +397,7 @@ class EC2RebootInstanceOperator(BaseOperator):
             )
 
 
-class EC2HibernateInstanceOperator(BaseOperator):
+class EC2HibernateInstanceOperator(AwsBaseOperator[EC2Hook]):
     """
     Hibernate Amazon EC2 instances.
 
@@ -401,11 +407,13 @@ class EC2HibernateInstanceOperator(BaseOperator):
 
     :param instance_ids: ID of the instance(s) to be hibernated.
     :param aws_conn_id: The Airflow connection used for AWS credentials.
-        If this is None or empty then the default boto3 behaviour is used. If
+        If this is ``None`` or empty then the default boto3 behaviour is used. If
         running Airflow in a distributed manner and aws_conn_id is None or
         empty, then default boto3 configuration would be used (and must be
         maintained on each worker node).
-    :param region_name: AWS region name associated with the client.
+    :param region_name: AWS region_name. If not specified then the default boto3 behaviour is used.
+    :param verify: Whether or not to verify SSL certificates. See:
+        https://boto3.amazonaws.com/v1/documentation/api/latest/reference/core/session.html
     :param poll_interval: Number of seconds to wait before attempting to
         check state of instance. Only used if wait_for_completion is True. Default is 20.
     :param max_attempts: Maximum number of attempts when checking state of instance.
@@ -414,8 +422,9 @@ class EC2HibernateInstanceOperator(BaseOperator):
         in the `stopped` state before returning.
     """
 
+    aws_hook_class = EC2Hook
     operator_extra_links = (EC2InstanceDashboardLink(),)
-    template_fields: Sequence[str] = ("instance_ids", "region_name")
+    template_fields: Sequence[str] = aws_template_fields("instance_ids", "region_name")
     ui_color = "#eeaa11"
     ui_fgcolor = "#ffffff"
 
@@ -423,8 +432,6 @@ class EC2HibernateInstanceOperator(BaseOperator):
         self,
         *,
         instance_ids: str | list[str],
-        aws_conn_id: str | None = "aws_default",
-        region_name: str | None = None,
         poll_interval: int = 20,
         max_attempts: int = 20,
         wait_for_completion: bool = False,
@@ -432,25 +439,26 @@ class EC2HibernateInstanceOperator(BaseOperator):
     ):
         super().__init__(**kwargs)
         self.instance_ids = instance_ids
-        self.aws_conn_id = aws_conn_id
-        self.region_name = region_name
         self.poll_interval = poll_interval
         self.max_attempts = max_attempts
         self.wait_for_completion = wait_for_completion
 
+    @property
+    def _hook_parameters(self) -> dict[str, Any]:
+        return {**super()._hook_parameters, "api_type": "client_type"}
+
     def execute(self, context: Context):
         if isinstance(self.instance_ids, str):
             self.instance_ids = [self.instance_ids]
-        ec2_hook = EC2Hook(aws_conn_id=self.aws_conn_id, region_name=self.region_name, api_type="client_type")
         self.log.info("Hibernating EC2 instances %s", ", ".join(self.instance_ids))
-        instances = ec2_hook.get_instances(instance_ids=self.instance_ids)
+        instances = self.hook.get_instances(instance_ids=self.instance_ids)
 
         # Console link is for EC2 dashboard list, not individual instances
         EC2InstanceDashboardLink.persist(
             context=context,
             operator=self,
-            region_name=ec2_hook.conn_region_name,
-            aws_partition=ec2_hook.conn_partition,
+            region_name=self.hook.conn_region_name,
+            aws_partition=self.hook.conn_partition,
             instance_ids=EC2InstanceDashboardLink.format_instance_id_filter(self.instance_ids),
         )
 
@@ -459,10 +467,10 @@ class EC2HibernateInstanceOperator(BaseOperator):
             if not hibernation_options or not hibernation_options["Configured"]:
                 raise AirflowException(f"Instance {instance['InstanceId']} is not configured for hibernation")
 
-        ec2_hook.conn.stop_instances(InstanceIds=self.instance_ids, Hibernate=True)
+        self.hook.conn.stop_instances(InstanceIds=self.instance_ids, Hibernate=True)
 
         if self.wait_for_completion:
-            ec2_hook.get_waiter("instance_stopped").wait(
+            self.hook.get_waiter("instance_stopped").wait(
                 InstanceIds=self.instance_ids,
                 WaiterConfig={
                     "Delay": self.poll_interval,

airflow/providers/amazon/aws/operators/eks.py

@@ -338,7 +338,7 @@ class EksCreateClusterOperator(BaseOperator):
             fargate_pod_execution_role_arn=self.fargate_pod_execution_role_arn,
             fargate_selectors=self.fargate_selectors,
             create_fargate_profile_kwargs=self.create_fargate_profile_kwargs,
-            subnets=cast(list[str], self.resources_vpc_config.get("subnetIds")),
+            subnets=cast("list[str]", self.resources_vpc_config.get("subnetIds")),
         )
 
     def deferrable_create_cluster_next(self, context: Context, event: dict[str, Any] | None = None) -> None:
@@ -377,7 +377,7 @@ class EksCreateClusterOperator(BaseOperator):
                 fargate_pod_execution_role_arn=self.fargate_pod_execution_role_arn,
                 fargate_selectors=self.fargate_selectors,
                 create_fargate_profile_kwargs=self.create_fargate_profile_kwargs,
-                subnets=cast(list[str], self.resources_vpc_config.get("subnetIds")),
+                subnets=cast("list[str]", self.resources_vpc_config.get("subnetIds")),
             )
             if self.compute == "fargate":
                 self.defer(
@@ -503,7 +503,7 @@ class EksCreateNodegroupOperator(BaseOperator):
             nodegroup_subnets_list: list[str] = []
             if self.nodegroup_subnets != "":
                 try:
-                    nodegroup_subnets_list = cast(list, literal_eval(self.nodegroup_subnets))
+                    nodegroup_subnets_list = cast("list", literal_eval(self.nodegroup_subnets))
                 except ValueError:
                     self.log.warning(
                         "The nodegroup_subnets should be List or string representing "

airflow/providers/amazon/aws/operators/mwaa.py

@@ -19,10 +19,14 @@
 from __future__ import annotations
 
 from collections.abc import Sequence
-from typing import TYPE_CHECKING
+from typing import TYPE_CHECKING, Any
 
+from airflow.configuration import conf
+from airflow.exceptions import AirflowException
 from airflow.providers.amazon.aws.hooks.mwaa import MwaaHook
 from airflow.providers.amazon.aws.operators.base_aws import AwsBaseOperator
+from airflow.providers.amazon.aws.triggers.mwaa import MwaaDagRunCompletedTrigger
+from airflow.providers.amazon.aws.utils import validate_execute_complete_event
 from airflow.providers.amazon.aws.utils.mixins import aws_template_fields
 
 if TYPE_CHECKING:
@@ -48,6 +52,23 @@ class MwaaTriggerDagRunOperator(AwsBaseOperator[MwaaHook]):
     :param conf: Additional configuration parameters. The value of this field can be set only when creating
         the object. (templated)
     :param note: Contains manually entered notes by the user about the DagRun. (templated)
+
+    :param wait_for_completion: Whether to wait for DAG run to stop. (default: False)
+    :param waiter_delay: Time in seconds to wait between status checks. (default: 120)
+    :param waiter_max_attempts: Maximum number of attempts to check for DAG run completion. (default: 720)
+    :param deferrable: If True, the operator will wait asynchronously for the DAG run to stop.
+        This implies waiting for completion. This mode requires aiobotocore module to be installed.
+        (default: False)
+    :param aws_conn_id: The Airflow connection used for AWS credentials.
+        If this is ``None`` or empty then the default boto3 behaviour is used. If
+        running Airflow in a distributed manner and aws_conn_id is None or
+        empty, then default boto3 configuration would be used (and must be
+        maintained on each worker node).
+    :param region_name: AWS region_name. If not specified then the default boto3 behaviour is used.
+    :param verify: Whether or not to verify SSL certificates. See:
+        https://boto3.amazonaws.com/v1/documentation/api/latest/reference/core/session.html
+    :param botocore_config: Configuration dictionary (key-values) for botocore client. See:
+        https://botocore.amazonaws.com/v1/documentation/api/latest/reference/config.html
     """
 
     aws_hook_class = MwaaHook
@@ -74,6 +95,10 @@ class MwaaTriggerDagRunOperator(AwsBaseOperator[MwaaHook]):
         data_interval_end: str | None = None,
         conf: dict | None = None,
         note: str | None = None,
+        wait_for_completion: bool = False,
+        waiter_delay: int = 60,
+        waiter_max_attempts: int = 720,
+        deferrable: bool = conf.getboolean("operators", "default_deferrable", fallback=False),
         **kwargs,
     ):
         super().__init__(**kwargs)
@@ -85,6 +110,21 @@ class MwaaTriggerDagRunOperator(AwsBaseOperator[MwaaHook]):
         self.data_interval_end = data_interval_end
         self.conf = conf if conf else {}
         self.note = note
+        self.wait_for_completion = wait_for_completion
+        self.waiter_delay = waiter_delay
+        self.waiter_max_attempts = waiter_max_attempts
+        self.deferrable = deferrable
+
+    def execute_complete(self, context: Context, event: dict[str, Any] | None = None) -> dict:
+        validated_event = validate_execute_complete_event(event)
+        if validated_event["status"] != "success":
+            raise AirflowException(f"DAG run failed: {validated_event}")
+
+        dag_run_id = validated_event["dag_run_id"]
+        self.log.info("DAG run %s of DAG %s completed", dag_run_id, self.trigger_dag_id)
+        return self.hook.invoke_rest_api(
+            env_name=self.env_name, path=f"/dags/{self.trigger_dag_id}/dagRuns/{dag_run_id}", method="GET"
+        )
 
     def execute(self, context: Context) -> dict:
         """
@@ -94,7 +134,7 @@ class MwaaTriggerDagRunOperator(AwsBaseOperator[MwaaHook]):
         :return: dict with information about the Dag run
             For details of the returned dict, see :py:meth:`botocore.client.MWAA.invoke_rest_api`
         """
-        return self.hook.invoke_rest_api(
+        response = self.hook.invoke_rest_api(
             env_name=self.env_name,
             path=f"/dags/{self.trigger_dag_id}/dagRuns",
             method="POST",
@@ -107,3 +147,34 @@ class MwaaTriggerDagRunOperator(AwsBaseOperator[MwaaHook]):
                 "note": self.note,
             },
         )
+
+        dag_run_id = response["RestApiResponse"]["dag_run_id"]
+        self.log.info("DAG run %s of DAG %s created", dag_run_id, self.trigger_dag_id)
+
+        task_description = f"DAG run {dag_run_id} of DAG {self.trigger_dag_id} to complete"
+        if self.deferrable:
+            self.log.info("Deferring for %s", task_description)
+            self.defer(
+                trigger=MwaaDagRunCompletedTrigger(
+                    external_env_name=self.env_name,
+                    external_dag_id=self.trigger_dag_id,
+                    external_dag_run_id=dag_run_id,
+                    waiter_delay=self.waiter_delay,
+                    waiter_max_attempts=self.waiter_max_attempts,
+                    aws_conn_id=self.aws_conn_id,
+                ),
+                method_name="execute_complete",
+            )
+        elif self.wait_for_completion:
+            self.log.info("Waiting for %s", task_description)
+            api_kwargs = {
+                "Name": self.env_name,
+                "Path": f"/dags/{self.trigger_dag_id}/dagRuns/{dag_run_id}",
+                "Method": "GET",
+            }
+            self.hook.get_waiter("mwaa_dag_run_complete").wait(
+                **api_kwargs,
+                WaiterConfig={"Delay": self.waiter_delay, "MaxAttempts": self.waiter_max_attempts},
+            )
+
+        return response

airflow/providers/amazon/aws/operators/redshift_cluster.py

@@ -755,11 +755,18 @@ class RedshiftDeleteClusterOperator(BaseOperator):
                     final_cluster_snapshot_identifier=self.final_cluster_snapshot_identifier,
                 )
                 break
-            except self.redshift_hook.get_conn().exceptions.InvalidClusterStateFault:
+            except self.redshift_hook.conn.exceptions.InvalidClusterStateFault:
                 self._attempts -= 1
 
                 if self._attempts:
-                    self.log.error("Unable to delete cluster. %d attempts remaining.", self._attempts)
+                    current_state = self.redshift_hook.conn.describe_clusters(
+                        ClusterIdentifier=self.cluster_identifier
+                    )["Clusters"][0]["ClusterStatus"]
+                    self.log.error(
+                        "Cluster in %s state, unable to delete. %d attempts remaining.",
+                        current_state,
+                        self._attempts,
+                    )
                     time.sleep(self._attempt_interval)
                 else:
                     raise
@@ -785,7 +792,7 @@ class RedshiftDeleteClusterOperator(BaseOperator):
                 )
 
         elif self.wait_for_completion:
-            waiter = self.redshift_hook.get_conn().get_waiter("cluster_deleted")
+            waiter = self.redshift_hook.conn.get_waiter("cluster_deleted")
             waiter.wait(
                 ClusterIdentifier=self.cluster_identifier,
                 WaiterConfig={"Delay": self.poll_interval, "MaxAttempts": self.max_attempts},