apache-airflow-providers-cncf-kubernetes 8.0.0rc1__tar.gz → 8.0.0rc3__tar.gz

{apache_airflow_providers_cncf_kubernetes-8.0.0rc1 → apache_airflow_providers_cncf_kubernetes-8.0.0rc3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: apache-airflow-providers-cncf-kubernetes
-Version: 8.0.0rc1
+Version: 8.0.0rc3
 Summary: Provider package apache-airflow-providers-cncf-kubernetes for Apache Airflow
 Keywords: airflow-provider,cncf.kubernetes,airflow,integration
 Author-email: Apache Software Foundation <dev@airflow.apache.org>
@@ -79,7 +79,7 @@ Project-URL: YouTube, https://www.youtube.com/channel/UCSXwxpWZQ7XZ1WL3wqevChA/
 
 Package ``apache-airflow-providers-cncf-kubernetes``
 
-Release: ``8.0.0.rc1``
+Release: ``8.0.0.rc3``
 
 
 `Kubernetes <https://kubernetes.io/>`__

{apache_airflow_providers_cncf_kubernetes-8.0.0rc1 → apache_airflow_providers_cncf_kubernetes-8.0.0rc3}/README.rst

@@ -42,7 +42,7 @@
 
 Package ``apache-airflow-providers-cncf-kubernetes``
 
-Release: ``8.0.0.rc1``
+Release: ``8.0.0.rc3``
 
 
 `Kubernetes <https://kubernetes.io/>`__

{apache_airflow_providers_cncf_kubernetes-8.0.0rc1 → apache_airflow_providers_cncf_kubernetes-8.0.0rc3}/airflow/providers/cncf/kubernetes/executors/kubernetes_executor.py

@@ -442,7 +442,7 @@ class KubernetesExecutor(BaseExecutor):
                     retries = self.task_publish_retries[key]
                     # In case of exceeded quota errors, requeue the task as per the task_publish_max_retries
                     if (
-                        e.status == 403
+                        str(e.status) == "403"
                         and "exceeded quota" in body["message"]
                         and (self.task_publish_max_retries == -1 or retries < self.task_publish_max_retries)
                     ):

{apache_airflow_providers_cncf_kubernetes-8.0.0rc1 → apache_airflow_providers_cncf_kubernetes-8.0.0rc3}/airflow/providers/cncf/kubernetes/executors/kubernetes_executor_utils.py

@@ -136,7 +136,7 @@ class KubernetesJobWatcher(multiprocessing.Process, LoggingMixin):
             else:
                 return watcher.stream(kube_client.list_namespaced_pod, self.namespace, **query_kwargs)
         except ApiException as e:
-            if e.status == 410:  # Resource version is too old
+            if str(e.status) == "410":  # Resource version is too old
                 if self.namespace == ALL_NAMESPACES:
                     pods = kube_client.list_pod_for_all_namespaces(watch=False)
                 else:
@@ -425,7 +425,7 @@ class AirflowKubernetesScheduler(LoggingMixin):
             )
         except ApiException as e:
             # If the pod is already deleted
-            if e.status != 404:
+            if str(e.status) != "404":
                 raise
 
     def patch_pod_executor_done(self, *, pod_name: str, namespace: str):

{apache_airflow_providers_cncf_kubernetes-8.0.0rc1 → apache_airflow_providers_cncf_kubernetes-8.0.0rc3}/airflow/providers/cncf/kubernetes/get_provider_info.py

@@ -115,6 +115,7 @@ def get_provider_info():
                     "airflow.providers.cncf.kubernetes.operators.pod",
                     "airflow.providers.cncf.kubernetes.operators.spark_kubernetes",
                     "airflow.providers.cncf.kubernetes.operators.resource",
+                    "airflow.providers.cncf.kubernetes.operators.job",
                 ],
             }
         ],

{apache_airflow_providers_cncf_kubernetes-8.0.0rc1 → apache_airflow_providers_cncf_kubernetes-8.0.0rc3}/airflow/providers/cncf/kubernetes/hooks/kubernetes.py

@@ -37,7 +37,7 @@ from airflow.providers.cncf.kubernetes.utils.pod_manager import PodOperatorHookP
 from airflow.utils import yaml
 
 if TYPE_CHECKING:
-    from kubernetes.client.models import V1Pod
+    from kubernetes.client.models import V1Deployment, V1Job, V1Pod
 
 LOADING_KUBE_CONFIG_FILE_RESOURCE = "Loading Kubernetes configuration file kube_config from {}..."
 
@@ -282,10 +282,18 @@ class KubernetesHook(BaseHook, PodOperatorHookProtocol):
     def core_v1_client(self) -> client.CoreV1Api:
         return client.CoreV1Api(api_client=self.api_client)
 
+    @cached_property
+    def apps_v1_client(self) -> client.AppsV1Api:
+        return client.AppsV1Api(api_client=self.api_client)
+
     @cached_property
     def custom_object_client(self) -> client.CustomObjectsApi:
         return client.CustomObjectsApi(api_client=self.api_client)
 
+    @cached_property
+    def batch_v1_client(self) -> client.BatchV1Api:
+        return client.BatchV1Api(api_client=self.api_client)
+
     def create_custom_object(
         self, group: str, version: str, plural: str, body: str | dict, namespace: str | None = None
     ):
@@ -450,6 +458,50 @@ class KubernetesHook(BaseHook, PodOperatorHookProtocol):
             **kwargs,
         )
 
+    def get_deployment_status(
+        self,
+        name: str,
+        namespace: str = "default",
+        **kwargs,
+    ) -> V1Deployment:
+        """Get status of existing Deployment.
+
+        :param name: Name of Deployment to retrieve
+        :param namespace: Deployment namespace
+        """
+        try:
+            return self.apps_v1_client.read_namespaced_deployment_status(
+                name=name, namespace=namespace, pretty=True, **kwargs
+            )
+        except Exception as exc:
+            raise exc
+
+    def create_job(
+        self,
+        job: V1Job,
+        **kwargs,
+    ) -> V1Job:
+        """
+        Run Job.
+
+        :param job: A kubernetes Job object
+        """
+        sanitized_job = self.batch_v1_client.api_client.sanitize_for_serialization(job)
+        json_job = json.dumps(sanitized_job, indent=2)
+
+        self.log.debug("Job Creation Request: \n%s", json_job)
+        try:
+            resp = self.batch_v1_client.create_namespaced_job(
+                body=sanitized_job, namespace=job.metadata.namespace, **kwargs
+            )
+            self.log.debug("Job Creation Response: %s", resp)
+        except Exception as e:
+            self.log.exception(
+                "Exception when attempting to create Namespaced Job: %s", str(json_job).replace("\n", " ")
+            )
+            raise e
+        return resp
+
 
 def _get_bool(val) -> bool | None:
     """Convert val to bool if can be done with certainty; if we cannot infer intention we return None."""
@@ -584,7 +636,7 @@ class AsyncKubernetesHook(KubernetesHook):
                 )
             except async_client.ApiException as e:
                 # If the pod is already deleted
-                if e.status != 404:
+                if str(e.status) != "404":
                     raise
 
     async def read_logs(self, name: str, namespace: str):

{apache_airflow_providers_cncf_kubernetes-8.0.0rc1 → apache_airflow_providers_cncf_kubernetes-8.0.0rc3}/airflow/providers/cncf/kubernetes/kubernetes_helper_functions.py

@@ -19,6 +19,7 @@ from __future__ import annotations
 import logging
 import secrets
 import string
+import warnings
 from typing import TYPE_CHECKING
 
 import pendulum
@@ -26,6 +27,7 @@ from slugify import slugify
 
 from airflow.compat.functools import cache
 from airflow.configuration import conf
+from airflow.exceptions import AirflowProviderDeprecationWarning
 
 if TYPE_CHECKING:
     from airflow.models.taskinstancekey import TaskInstanceKey
@@ -45,6 +47,18 @@ def rand_str(num):
     return "".join(secrets.choice(alphanum_lower) for _ in range(num))
 
 
+def add_unique_suffix(*, name: str, rand_len: int = 8, max_len: int = POD_NAME_MAX_LENGTH) -> str:
+    """Add random string to pod or job name while staying under max length.
+
+    :param name: name of the pod or job
+    :param rand_len: length of the random string to append
+    :param max_len: maximum length of the pod name
+    :meta private:
+    """
+    suffix = "-" + rand_str(rand_len)
+    return name[: max_len - len(suffix)].strip("-.") + suffix
+
+
 def add_pod_suffix(*, pod_name: str, rand_len: int = 8, max_len: int = POD_NAME_MAX_LENGTH) -> str:
     """Add random string to pod name while staying under max length.
 
@@ -53,10 +67,48 @@ def add_pod_suffix(*, pod_name: str, rand_len: int = 8, max_len: int = POD_NAME_
     :param max_len: maximum length of the pod name
     :meta private:
     """
+    warnings.warn(
+        "This function is deprecated. Please use `add_unique_suffix`.",
+        AirflowProviderDeprecationWarning,
+        stacklevel=2,
+    )
+
     suffix = "-" + rand_str(rand_len)
     return pod_name[: max_len - len(suffix)].strip("-.") + suffix
 
 
+def create_unique_id(
+    dag_id: str | None = None,
+    task_id: str | None = None,
+    *,
+    max_length: int = POD_NAME_MAX_LENGTH,
+    unique: bool = True,
+) -> str:
+    """
+    Generate unique pod or job ID given a dag_id and / or task_id.
+
+    :param dag_id: DAG ID
+    :param task_id: Task ID
+    :param max_length: max number of characters
+    :param unique: whether a random string suffix should be added
+    :return: A valid identifier for a kubernetes pod name
+    """
+    if not (dag_id or task_id):
+        raise ValueError("Must supply either dag_id or task_id.")
+    name = ""
+    if dag_id:
+        name += dag_id
+    if task_id:
+        if name:
+            name += "-"
+        name += task_id
+    base_name = slugify(name, lowercase=True)[:max_length].strip(".-")
+    if unique:
+        return add_pod_suffix(pod_name=base_name, rand_len=8, max_len=max_length)
+    else:
+        return base_name
+
+
 def create_pod_id(
     dag_id: str | None = None,
     task_id: str | None = None,
@@ -73,6 +125,12 @@ def create_pod_id(
     :param unique: whether a random string suffix should be added
     :return: A valid identifier for a kubernetes pod name
     """
+    warnings.warn(
+        "This function is deprecated. Please use `create_unique_id`.",
+        AirflowProviderDeprecationWarning,
+        stacklevel=2,
+    )
+
     if not (dag_id or task_id):
         raise ValueError("Must supply either dag_id or task_id.")
     name = ""

{apache_airflow_providers_cncf_kubernetes-8.0.0rc1 → apache_airflow_providers_cncf_kubernetes-8.0.0rc3}/airflow/providers/cncf/kubernetes/operators/custom_object_launcher.py

@@ -43,7 +43,7 @@ from airflow.utils.log.logging_mixin import LoggingMixin
 def should_retry_start_spark_job(exception: BaseException) -> bool:
     """Check if an Exception indicates a transient error and warrants retrying."""
     if isinstance(exception, ApiException):
-        return exception.status == 409
+        return str(exception.status) == "409"
     return False
 
 
@@ -363,5 +363,5 @@ class CustomObjectLauncher(LoggingMixin):
             )
         except ApiException as e:
             # If the pod is already deleted
-            if e.status != 404:
+            if str(e.status) != "404":
                 raise

apache_airflow_providers_cncf_kubernetes-8.0.0rc3/airflow/providers/cncf/kubernetes/operators/job.py

@@ -0,0 +1,286 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+"""Executes a Kubernetes Job."""
+from __future__ import annotations
+
+import copy
+import logging
+import os
+from functools import cached_property
+from typing import TYPE_CHECKING, Sequence
+
+from kubernetes.client import BatchV1Api, models as k8s
+from kubernetes.client.api_client import ApiClient
+
+from airflow.providers.cncf.kubernetes.hooks.kubernetes import KubernetesHook
+from airflow.providers.cncf.kubernetes.kubernetes_helper_functions import (
+    add_unique_suffix,
+    create_unique_id,
+)
+from airflow.providers.cncf.kubernetes.operators.pod import KubernetesPodOperator
+from airflow.providers.cncf.kubernetes.pod_generator import PodGenerator, merge_objects
+from airflow.utils import yaml
+
+if TYPE_CHECKING:
+    from airflow.utils.context import Context
+
+log = logging.getLogger(__name__)
+
+
+class KubernetesJobOperator(KubernetesPodOperator):
+    """
+    Executes a Kubernetes Job.
+
+    .. seealso::
+        For more information on how to use this operator, take a look at the guide:
+        :ref:`howto/operator:KubernetesJobOperator`
+
+    .. note::
+        If you use `Google Kubernetes Engine <https://cloud.google.com/kubernetes-engine/>`__
+        and Airflow is not running in the same cluster, consider using
+        :class:`~airflow.providers.google.cloud.operators.kubernetes_engine.GKEStartJobOperator`, which
+        simplifies the authorization process.
+
+    :param job_template_file: path to job template file (templated)
+    :param full_job_spec: The complete JodSpec
+    :param backoff_limit: Specifies the number of retries before marking this job failed. Defaults to 6
+    :param completion_mode: CompletionMode specifies how Pod completions are tracked. It can be `NonIndexed` (default) or `Indexed`.
+    :param completions: Specifies the desired number of successfully finished pods the job should be run with.
+    :param manual_selector: manualSelector controls generation of pod labels and pod selectors.
+    :param parallelism: Specifies the maximum desired number of pods the job should run at any given time.
+    :param selector: The selector of this V1JobSpec.
+    :param suspend: Suspend specifies whether the Job controller should create Pods or not.
+    :param ttl_seconds_after_finished: ttlSecondsAfterFinished limits the lifetime of a Job that has finished execution (either Complete or Failed).
+    """
+
+    template_fields: Sequence[str] = tuple({"job_template_file"} | set(KubernetesPodOperator.template_fields))
+
+    def __init__(
+        self,
+        *,
+        job_template_file: str | None = None,
+        full_job_spec: k8s.V1Job | None = None,
+        backoff_limit: int | None = None,
+        completion_mode: str | None = None,
+        completions: int | None = None,
+        manual_selector: bool | None = None,
+        parallelism: int | None = None,
+        selector: k8s.V1LabelSelector | None = None,
+        suspend: bool | None = None,
+        ttl_seconds_after_finished: int | None = None,
+        **kwargs,
+    ) -> None:
+        super().__init__(**kwargs)
+        self.job_template_file = job_template_file
+        self.full_job_spec = full_job_spec
+        self.job_request_obj: k8s.V1Job | None = None
+        self.job: k8s.V1Job | None = None
+        self.backoff_limit = backoff_limit
+        self.completion_mode = completion_mode
+        self.completions = completions
+        self.manual_selector = manual_selector
+        self.parallelism = parallelism
+        self.selector = selector
+        self.suspend = suspend
+        self.ttl_seconds_after_finished = ttl_seconds_after_finished
+
+    @cached_property
+    def _incluster_namespace(self):
+        from pathlib import Path
+
+        path = Path("/var/run/secrets/kubernetes.io/serviceaccount/namespace")
+        return path.exists() and path.read_text() or None
+
+    @cached_property
+    def hook(self) -> KubernetesHook:
+        hook = KubernetesHook(
+            conn_id=self.kubernetes_conn_id,
+            in_cluster=self.in_cluster,
+            config_file=self.config_file,
+            cluster_context=self.cluster_context,
+        )
+        return hook
+
+    @cached_property
+    def client(self) -> BatchV1Api:
+        return self.hook.batch_v1_client
+
+    def create_job(self, job_request_obj: k8s.V1Job) -> k8s.V1Job:
+        self.log.debug("Starting job:\n%s", yaml.safe_dump(job_request_obj.to_dict()))
+        self.hook.create_job(job=job_request_obj)
+
+        return job_request_obj
+
+    def execute(self, context: Context):
+        self.job_request_obj = self.build_job_request_obj(context)
+        self.job = self.create_job(  # must set `self.job` for `on_kill`
+            job_request_obj=self.job_request_obj
+        )
+
+        ti = context["ti"]
+        ti.xcom_push(key="job_name", value=self.job.metadata.name)
+        ti.xcom_push(key="job_namespace", value=self.job.metadata.namespace)
+
+    @staticmethod
+    def deserialize_job_template_file(path: str) -> k8s.V1Job:
+        """
+        Generate a Job from a file.
+
+        Unfortunately we need access to the private method
+        ``_ApiClient__deserialize_model`` from the kubernetes client.
+        This issue is tracked here: https://github.com/kubernetes-client/python/issues/977.
+
+        :param path: Path to the file
+        :return: a kubernetes.client.models.V1Job
+        """
+        if os.path.exists(path):
+            with open(path) as stream:
+                job = yaml.safe_load(stream)
+        else:
+            job = None
+            log.warning("Template file %s does not exist", path)
+
+        api_client = ApiClient()
+        return api_client._ApiClient__deserialize_model(job, k8s.V1Job)
+
+    def on_kill(self) -> None:
+        if self.job:
+            job = self.job
+            kwargs = {
+                "name": job.metadata.name,
+                "namespace": job.metadata.namespace,
+            }
+            if self.termination_grace_period is not None:
+                kwargs.update(grace_period_seconds=self.termination_grace_period)
+            self.client.delete_namespaced_job(**kwargs)
+
+    def build_job_request_obj(self, context: Context | None = None) -> k8s.V1Job:
+        """
+        Return V1Job object based on job template file, full job spec, and other operator parameters.
+
+        The V1Job attributes are derived (in order of precedence) from operator params, full job spec, job
+        template file.
+        """
+        self.log.debug("Creating job for KubernetesJobOperator task %s", self.task_id)
+        if self.job_template_file:
+            self.log.debug("Job template file found, will parse for base job")
+            job_template = self.deserialize_job_template_file(self.job_template_file)
+            if self.full_job_spec:
+                job_template = self.reconcile_jobs(job_template, self.full_job_spec)
+        elif self.full_job_spec:
+            job_template = self.full_job_spec
+        else:
+            job_template = k8s.V1Job(metadata=k8s.V1ObjectMeta())
+
+        pod_template = super().build_pod_request_obj(context)
+        pod_template_spec = k8s.V1PodTemplateSpec(
+            metadata=pod_template.metadata,
+            spec=pod_template.spec,
+        )
+
+        job = k8s.V1Job(
+            api_version="batch/v1",
+            kind="Job",
+            metadata=k8s.V1ObjectMeta(
+                namespace=self.namespace,
+                labels=self.labels,
+                name=self.name,
+                annotations=self.annotations,
+            ),
+            spec=k8s.V1JobSpec(
+                active_deadline_seconds=self.active_deadline_seconds,
+                backoff_limit=self.backoff_limit,
+                completion_mode=self.completion_mode,
+                completions=self.completions,
+                manual_selector=self.manual_selector,
+                parallelism=self.parallelism,
+                selector=self.selector,
+                suspend=self.suspend,
+                template=pod_template_spec,
+                ttl_seconds_after_finished=self.ttl_seconds_after_finished,
+            ),
+        )
+
+        job = self.reconcile_jobs(job_template, job)
+
+        if not job.metadata.name:
+            job.metadata.name = create_unique_id(
+                task_id=self.task_id, unique=self.random_name_suffix, max_length=80
+            )
+        elif self.random_name_suffix:
+            # user has supplied job name, we're just adding suffix
+            job.metadata.name = add_unique_suffix(name=job.metadata.name)
+
+        job.metadata.name = f"job-{job.metadata.name}"
+
+        if not job.metadata.namespace:
+            hook_namespace = self.hook.get_namespace()
+            job_namespace = self.namespace or hook_namespace or self._incluster_namespace or "default"
+            job.metadata.namespace = job_namespace
+
+        self.log.info("Building job %s ", job.metadata.name)
+
+        return job
+
+    @staticmethod
+    def reconcile_jobs(base_job: k8s.V1Job, client_job: k8s.V1Job | None) -> k8s.V1Job:
+        """
+        Merge Kubernetes Job objects.
+
+        :param base_job: has the base attributes which are overwritten if they exist
+            in the client job and remain if they do not exist in the client_job
+        :param client_job: the job that the client wants to create.
+        :return: the merged jobs
+
+        This can't be done recursively as certain fields are overwritten and some are concatenated.
+        """
+        if client_job is None:
+            return base_job
+
+        client_job_cp = copy.deepcopy(client_job)
+        client_job_cp.spec = KubernetesJobOperator.reconcile_job_specs(base_job.spec, client_job_cp.spec)
+        client_job_cp.metadata = PodGenerator.reconcile_metadata(base_job.metadata, client_job_cp.metadata)
+        client_job_cp = merge_objects(base_job, client_job_cp)
+
+        return client_job_cp
+
+    @staticmethod
+    def reconcile_job_specs(
+        base_spec: k8s.V1JobSpec | None, client_spec: k8s.V1JobSpec | None
+    ) -> k8s.V1JobSpec | None:
+        """
+        Merge Kubernetes JobSpec objects.
+
+        :param base_spec: has the base attributes which are overwritten if they exist
+            in the client_spec and remain if they do not exist in the client_spec
+        :param client_spec: the spec that the client wants to create.
+        :return: the merged specs
+        """
+        if base_spec and not client_spec:
+            return base_spec
+        if not base_spec and client_spec:
+            return client_spec
+        elif client_spec and base_spec:
+            client_spec.template.spec = PodGenerator.reconcile_specs(
+                base_spec.template.spec, client_spec.template.spec
+            )
+            client_spec.template.metadata = PodGenerator.reconcile_metadata(
+                base_spec.template.metadata, client_spec.template.metadata
+            )
+            return merge_objects(base_spec, client_spec)
+
+        return None

{apache_airflow_providers_cncf_kubernetes-8.0.0rc1 → apache_airflow_providers_cncf_kubernetes-8.0.0rc3}/airflow/providers/cncf/kubernetes/operators/pod.py

@@ -18,6 +18,7 @@
 
 from __future__ import annotations
 
+import datetime
 import json
 import logging
 import re
@@ -30,6 +31,7 @@ from functools import cached_property
 from typing import TYPE_CHECKING, Any, Callable, Iterable, Sequence
 
 import kubernetes
+from deprecated import deprecated
 from kubernetes.client import CoreV1Api, V1Pod, models as k8s
 from kubernetes.stream import stream
 from urllib3.exceptions import HTTPError
@@ -68,7 +70,6 @@ from airflow.providers.cncf.kubernetes.utils.pod_manager import (
     EMPTY_XCOM_RESULT,
     OnFinishAction,
     PodLaunchFailedException,
-    PodLaunchTimeoutException,
     PodManager,
     PodNotFoundException,
     PodOperatorHookProtocol,
@@ -79,7 +80,6 @@ from airflow.providers.cncf.kubernetes.utils.pod_manager import (
 from airflow.settings import pod_mutation_hook
 from airflow.utils import yaml
 from airflow.utils.helpers import prune_dict, validate_key
-from airflow.utils.timezone import utcnow
 from airflow.version import version as airflow_version
 
 if TYPE_CHECKING:
@@ -656,7 +656,7 @@ class KubernetesPodOperator(BaseOperator):
 
     def invoke_defer_method(self, last_log_time: DateTime | None = None):
         """Redefine triggers which are being used in child classes."""
-        trigger_start_time = utcnow()
+        trigger_start_time = datetime.datetime.now(tz=datetime.timezone.utc)
         self.defer(
             trigger=KubernetesPodTrigger(
                 pod_name=self.pod.metadata.name,  # type: ignore[union-attr]
@@ -678,117 +678,93 @@ class KubernetesPodOperator(BaseOperator):
             method_name="trigger_reentry",
         )
 
-    @staticmethod
-    def raise_for_trigger_status(event: dict[str, Any]) -> None:
-        """Raise exception if pod is not in expected state."""
-        if event["status"] == "error":
-            error_type = event["error_type"]
-            description = event["description"]
-            if error_type == "PodLaunchTimeoutException":
-                raise PodLaunchTimeoutException(description)
-            else:
-                raise AirflowException(description)
-
     def trigger_reentry(self, context: Context, event: dict[str, Any]) -> Any:
         """
         Point of re-entry from trigger.
 
-        If ``logging_interval`` is None, then at this point the pod should be done and we'll just fetch
+        If ``logging_interval`` is None, then at this point, the pod should be done, and we'll just fetch
         the logs and exit.
 
-        If ``logging_interval`` is not None, it could be that the pod is still running and we'll just
+        If ``logging_interval`` is not None, it could be that the pod is still running, and we'll just
         grab the latest logs and defer back to the trigger again.
         """
-        remote_pod = None
+        self.pod = None
         try:
-            self.pod_request_obj = self.build_pod_request_obj(context)
-            self.pod = self.find_pod(
-                namespace=self.namespace or self.pod_request_obj.metadata.namespace,
-                context=context,
-            )
+            pod_name = event["name"]
+            pod_namespace = event["namespace"]
 
-            # we try to find pod before possibly raising so that on_kill will have `pod` attr
-            self.raise_for_trigger_status(event)
+            self.pod = self.hook.get_pod(pod_name, pod_namespace)
 
             if not self.pod:
                 raise PodNotFoundException("Could not find pod after resuming from deferral")
 
-            if self.get_logs:
-                last_log_time = event and event.get("last_log_time")
-                if last_log_time:
-                    self.log.info("Resuming logs read from time %r", last_log_time)
-                pod_log_status = self.pod_manager.fetch_container_logs(
-                    pod=self.pod,
-                    container_name=self.BASE_CONTAINER_NAME,
-                    follow=self.logging_interval is None,
-                    since_time=last_log_time,
-                )
-                if pod_log_status.running:
-                    self.log.info("Container still running; deferring again.")
-                    self.invoke_defer_method(pod_log_status.last_log_time)
-
-            if self.do_xcom_push:
-                result = self.extract_xcom(pod=self.pod)
-            remote_pod = self.pod_manager.await_pod_completion(self.pod)
-        except TaskDeferred:
-            raise
-        except Exception:
-            self.cleanup(
-                pod=self.pod or self.pod_request_obj,
-                remote_pod=remote_pod,
-            )
-            raise
-        self.cleanup(
-            pod=self.pod or self.pod_request_obj,
-            remote_pod=remote_pod,
-        )
-        if self.do_xcom_push:
-            return result
-
-    def execute_complete(self, context: Context, event: dict, **kwargs):
-        self.log.debug("Triggered with event: %s", event)
-        pod = None
-        try:
-            pod = self.hook.get_pod(
-                event["name"],
-                event["namespace"],
-            )
-            if self.callbacks:
+            if self.callbacks and event["status"] != "running":
                 self.callbacks.on_operator_resuming(
-                    pod=pod, event=event, client=self.client, mode=ExecutionMode.SYNC
+                    pod=self.pod, event=event, client=self.client, mode=ExecutionMode.SYNC
                 )
+
             if event["status"] in ("error", "failed", "timeout"):
                 # fetch some logs when pod is failed
                 if self.get_logs:
-                    self.write_logs(pod)
-                if "stack_trace" in event:
-                    message = f"{event['message']}\n{event['stack_trace']}"
-                else:
-                    message = event["message"]
+                    self.write_logs(self.pod)
+
                 if self.do_xcom_push:
-                    # In the event of base container failure, we need to kill the xcom sidecar.
-                    # We disregard xcom output and do that here
-                    _ = self.extract_xcom(pod=pod)
+                    _ = self.extract_xcom(pod=self.pod)
+
+                message = event.get("stack_trace", event["message"])
                 raise AirflowException(message)
+
+            elif event["status"] == "running":
+                if self.get_logs:
+                    last_log_time = event.get("last_log_time")
+                    self.log.info("Resuming logs read from time %r", last_log_time)
+
+                    pod_log_status = self.pod_manager.fetch_container_logs(
+                        pod=self.pod,
+                        container_name=self.BASE_CONTAINER_NAME,
+                        follow=self.logging_interval is None,
+                        since_time=last_log_time,
+                    )
+
+                    if pod_log_status.running:
+                        self.log.info("Container still running; deferring again.")
+                        self.invoke_defer_method(pod_log_status.last_log_time)
+                else:
+                    self.invoke_defer_method()
+
             elif event["status"] == "success":
                 # fetch some logs when pod is executed successfully
                 if self.get_logs:
-                    self.write_logs(pod)
+                    self.write_logs(self.pod)
 
                 if self.do_xcom_push:
-                    xcom_sidecar_output = self.extract_xcom(pod=pod)
+                    xcom_sidecar_output = self.extract_xcom(pod=self.pod)
                     return xcom_sidecar_output
+                return
+        except TaskDeferred:
+            raise
         finally:
-            istio_enabled = self.is_istio_enabled(pod)
-            # Skip await_pod_completion when the event is 'timeout' due to the pod can hang
-            # on the ErrImagePull or ContainerCreating step and it will never complete
-            if event["status"] != "timeout":
-                pod = self.pod_manager.await_pod_completion(pod, istio_enabled, self.base_container_name)
-            if pod is not None:
-                self.post_complete_action(
-                    pod=pod,
-                    remote_pod=pod,
-                )
+            self._clean(event)
+
+    def _clean(self, event: dict[str, Any]):
+        if event["status"] == "running":
+            return
+        istio_enabled = self.is_istio_enabled(self.pod)
+        # Skip await_pod_completion when the event is 'timeout' due to the pod can hang
+        # on the ErrImagePull or ContainerCreating step and it will never complete
+        if event["status"] != "timeout":
+            self.pod = self.pod_manager.await_pod_completion(
+                self.pod, istio_enabled, self.base_container_name
+            )
+        if self.pod is not None:
+            self.post_complete_action(
+                pod=self.pod,
+                remote_pod=self.pod,
+            )
+
+    @deprecated(reason="use `trigger_reentry` instead.", category=AirflowProviderDeprecationWarning)
+    def execute_complete(self, context: Context, event: dict, **kwargs):
+        self.trigger_reentry(context=context, event=event)
 
     def write_logs(self, pod: k8s.V1Pod):
         try:

{apache_airflow_providers_cncf_kubernetes-8.0.0rc1 → apache_airflow_providers_cncf_kubernetes-8.0.0rc3}/airflow/providers/cncf/kubernetes/pod_launcher_deprecated.py

@@ -119,7 +119,7 @@ class PodLauncher(LoggingMixin):
             )
         except ApiException as e:
             # If the pod is already deleted
-            if e.status != 404:
+            if str(e.status) != "404":
                 raise
 
     def start_pod(self, pod: V1Pod, startup_timeout: int = 120):

{apache_airflow_providers_cncf_kubernetes-8.0.0rc1 → apache_airflow_providers_cncf_kubernetes-8.0.0rc3}/airflow/providers/cncf/kubernetes/triggers/pod.py

@@ -30,10 +30,8 @@ from airflow.providers.cncf.kubernetes.utils.pod_manager import (
     OnFinishAction,
     PodLaunchTimeoutException,
     PodPhase,
-    container_is_running,
 )
 from airflow.triggers.base import BaseTrigger, TriggerEvent
-from airflow.utils import timezone
 
 if TYPE_CHECKING:
     from kubernetes_asyncio.client.models import V1Pod
@@ -160,22 +158,50 @@ class KubernetesPodTrigger(BaseTrigger):
         self.log.info("Checking pod %r in namespace %r.", self.pod_name, self.pod_namespace)
         try:
             state = await self._wait_for_pod_start()
-            if state in PodPhase.terminal_states:
+            if state == ContainerState.TERMINATED:
                 event = TriggerEvent(
-                    {"status": "done", "namespace": self.pod_namespace, "pod_name": self.pod_name}
+                    {
+                        "status": "success",
+                        "namespace": self.pod_namespace,
+                        "name": self.pod_name,
+                        "message": "All containers inside pod have started successfully.",
+                    }
+                )
+            elif state == ContainerState.FAILED:
+                event = TriggerEvent(
+                    {
+                        "status": "failed",
+                        "namespace": self.pod_namespace,
+                        "name": self.pod_name,
+                        "message": "pod failed",
+                    }
                 )
             else:
                 event = await self._wait_for_container_completion()
             yield event
+            return
+        except PodLaunchTimeoutException as e:
+            message = self._format_exception_description(e)
+            yield TriggerEvent(
+                {
+                    "name": self.pod_name,
+                    "namespace": self.pod_namespace,
+                    "status": "timeout",
+                    "message": message,
+                }
+            )
+            return
         except Exception as e:
-            description = self._format_exception_description(e)
             yield TriggerEvent(
                 {
+                    "name": self.pod_name,
+                    "namespace": self.pod_namespace,
                     "status": "error",
-                    "error_type": e.__class__.__name__,
-                    "description": description,
+                    "message": str(e),
+                    "stack_trace": traceback.format_exc(),
                 }
             )
+            return
 
     def _format_exception_description(self, exc: Exception) -> Any:
         if isinstance(exc, PodLaunchTimeoutException):
@@ -189,16 +215,16 @@ class KubernetesPodTrigger(BaseTrigger):
         description += f"\ntrigger traceback:\n{curr_traceback}"
         return description
 
-    async def _wait_for_pod_start(self) -> Any:
+    async def _wait_for_pod_start(self) -> ContainerState:
         """Loops until pod phase leaves ``PENDING`` If timeout is reached, throws error."""
-        start_time = timezone.utcnow()
-        timeout_end = start_time + datetime.timedelta(seconds=self.startup_timeout)
-        while timeout_end > timezone.utcnow():
+        delta = datetime.datetime.now(tz=datetime.timezone.utc) - self.trigger_start_time
+        while self.startup_timeout >= delta.total_seconds():
             pod = await self.hook.get_pod(self.pod_name, self.pod_namespace)
             if not pod.status.phase == "Pending":
-                return pod.status.phase
+                return self.define_container_state(pod)
             self.log.info("Still waiting for pod to start. The pod state is %s", pod.status.phase)
             await asyncio.sleep(self.poll_interval)
+            delta = datetime.datetime.now(tz=datetime.timezone.utc) - self.trigger_start_time
         raise PodLaunchTimeoutException("Pod did not leave 'Pending' phase within specified timeout")
 
     async def _wait_for_container_completion(self) -> TriggerEvent:
@@ -208,18 +234,35 @@ class KubernetesPodTrigger(BaseTrigger):
         Waits until container is no longer in running state. If trigger is configured with a logging period,
         then will emit an event to resume the task for the purpose of fetching more logs.
         """
-        time_begin = timezone.utcnow()
+        time_begin = datetime.datetime.now(tz=datetime.timezone.utc)
         time_get_more_logs = None
         if self.logging_interval is not None:
             time_get_more_logs = time_begin + datetime.timedelta(seconds=self.logging_interval)
         while True:
             pod = await self.hook.get_pod(self.pod_name, self.pod_namespace)
-            if not container_is_running(pod=pod, container_name=self.base_container_name):
+            container_state = self.define_container_state(pod)
+            if container_state == ContainerState.TERMINATED:
+                return TriggerEvent(
+                    {"status": "success", "namespace": self.pod_namespace, "name": self.pod_name}
+                )
+            elif container_state == ContainerState.FAILED:
+                return TriggerEvent(
+                    {
+                        "status": "failed",
+                        "namespace": self.pod_namespace,
+                        "name": self.pod_name,
+                        "message": "Container state failed",
+                    }
+                )
+            if time_get_more_logs and datetime.datetime.now(tz=datetime.timezone.utc) > time_get_more_logs:
                 return TriggerEvent(
-                    {"status": "done", "namespace": self.pod_namespace, "pod_name": self.pod_name}
+                    {
+                        "status": "running",
+                        "last_log_time": self.last_log_time,
+                        "namespace": self.pod_namespace,
+                        "name": self.pod_name,
+                    }
                 )
-            if time_get_more_logs and timezone.utcnow() > time_get_more_logs:
-                return TriggerEvent({"status": "running", "last_log_time": self.last_log_time})
             await asyncio.sleep(self.poll_interval)
 
     def _get_async_hook(self) -> AsyncKubernetesHook:

{apache_airflow_providers_cncf_kubernetes-8.0.0rc1 → apache_airflow_providers_cncf_kubernetes-8.0.0rc3}/airflow/providers/cncf/kubernetes/utils/pod_manager.py

@@ -67,7 +67,7 @@ class PodLaunchFailedException(AirflowException):
 def should_retry_start_pod(exception: BaseException) -> bool:
     """Check if an Exception indicates a transient error and warrants retrying."""
     if isinstance(exception, ApiException):
-        return exception.status == 409
+        return str(exception.status) == "409"
     return False
 
 
@@ -340,7 +340,7 @@ class PodManager(LoggingMixin):
             )
         except ApiException as e:
             # If the pod is already deleted
-            if e.status != 404:
+            if str(e.status) != "404":
                 raise
 
     @tenacity.retry(

{apache_airflow_providers_cncf_kubernetes-8.0.0rc1 → apache_airflow_providers_cncf_kubernetes-8.0.0rc3}/pyproject.toml

@@ -28,7 +28,7 @@ build-backend = "flit_core.buildapi"
 
 [project]
 name = "apache-airflow-providers-cncf-kubernetes"
-version = "8.0.0.rc1"
+version = "8.0.0.rc3"
 description = "Provider package apache-airflow-providers-cncf-kubernetes for Apache Airflow"
 readme = "README.rst"
 authors = [