apache-airflow-providers-cncf-kubernetes 8.0.1__py3-none-any.whl → 8.1.0__py3-none-any.whl

airflow/providers/cncf/kubernetes/operators/pod.py

@@ -21,12 +21,14 @@ from __future__ import annotations
 import datetime
 import json
 import logging
+import math
 import re
 import shlex
 import string
 import warnings
 from collections.abc import Container
 from contextlib import AbstractContextManager
+from enum import Enum
 from functools import cached_property
 from typing import TYPE_CHECKING, Any, Callable, Iterable, Sequence
 
@@ -60,8 +62,8 @@ from airflow.providers.cncf.kubernetes.callbacks import ExecutionMode, Kubernete
 from airflow.providers.cncf.kubernetes.hooks.kubernetes import KubernetesHook
 from airflow.providers.cncf.kubernetes.kubernetes_helper_functions import (
     POD_NAME_MAX_LENGTH,
-    add_pod_suffix,
-    create_pod_id,
+    add_unique_suffix,
+    create_unique_id,
 )
 from airflow.providers.cncf.kubernetes.pod_generator import PodGenerator
 from airflow.providers.cncf.kubernetes.triggers.pod import KubernetesPodTrigger
@@ -95,6 +97,13 @@ alphanum_lower = string.ascii_lowercase + string.digits
 KUBE_CONFIG_ENV_VAR = "KUBECONFIG"
 
 
+class PodEventType(Enum):
+    """Type of Events emitted by kubernetes pod."""
+
+    WARNING = "Warning"
+    NORMAL = "Normal"
+
+
 class PodReattachFailure(AirflowException):
     """When we expect to be able to find a pod but cannot."""
 
@@ -266,7 +275,7 @@ class KubernetesPodOperator(BaseOperator):
         labels: dict | None = None,
         reattach_on_restart: bool = True,
         startup_timeout_seconds: int = 120,
-        startup_check_interval_seconds: int = 1,
+        startup_check_interval_seconds: int = 5,
         get_logs: bool = True,
         container_logs: Iterable[str] | str | Literal[True] = BASE_CONTAINER_NAME,
         image_pull_policy: str | None = None,
@@ -548,8 +557,7 @@ class KubernetesPodOperator(BaseOperator):
             )
         except PodLaunchFailedException:
             if self.log_events_on_failure:
-                for event in self.pod_manager.read_pod_events(pod).items:
-                    self.log.error("Pod Event: %s - %s", event.reason, event.message)
+                self._read_pod_events(pod, reraise=False)
             raise
 
     def extract_xcom(self, pod: k8s.V1Pod):
@@ -703,10 +711,13 @@ class KubernetesPodOperator(BaseOperator):
                     pod=self.pod, event=event, client=self.client, mode=ExecutionMode.SYNC
                 )
 
+            follow = self.logging_interval is None
+            last_log_time = event.get("last_log_time")
+
             if event["status"] in ("error", "failed", "timeout"):
                 # fetch some logs when pod is failed
                 if self.get_logs:
-                    self.write_logs(self.pod)
+                    self.write_logs(self.pod, follow=follow, since_time=last_log_time)
 
                 if self.do_xcom_push:
                     _ = self.extract_xcom(pod=self.pod)
@@ -716,13 +727,12 @@ class KubernetesPodOperator(BaseOperator):
 
             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,
+                        follow=follow,
                         since_time=last_log_time,
                     )
 
@@ -735,7 +745,7 @@ class KubernetesPodOperator(BaseOperator):
             elif event["status"] == "success":
                 # fetch some logs when pod is executed successfully
                 if self.get_logs:
-                    self.write_logs(self.pod)
+                    self.write_logs(self.pod, follow=follow, since_time=last_log_time)
 
                 if self.do_xcom_push:
                     xcom_sidecar_output = self.extract_xcom(pod=self.pod)
@@ -764,14 +774,20 @@ class KubernetesPodOperator(BaseOperator):
 
     @deprecated(reason="use `trigger_reentry` instead.", category=AirflowProviderDeprecationWarning)
     def execute_complete(self, context: Context, event: dict, **kwargs):
-        self.trigger_reentry(context=context, event=event)
+        return self.trigger_reentry(context=context, event=event)
 
-    def write_logs(self, pod: k8s.V1Pod):
+    def write_logs(self, pod: k8s.V1Pod, follow: bool = False, since_time: DateTime | None = None):
         try:
+            since_seconds = (
+                math.ceil((datetime.datetime.now(tz=datetime.timezone.utc) - since_time).total_seconds())
+                if since_time
+                else None
+            )
             logs = self.pod_manager.read_pod_logs(
                 pod=pod,
                 container_name=self.base_container_name,
-                follow=False,
+                follow=follow,
+                since_seconds=since_seconds,
             )
             for raw_line in logs:
                 line = raw_line.decode("utf-8", errors="backslashreplace").rstrip("\n")
@@ -855,7 +871,10 @@ class KubernetesPodOperator(BaseOperator):
         """Will fetch and emit events from pod."""
         with _optionally_suppress(reraise=reraise):
             for event in self.pod_manager.read_pod_events(pod).items:
-                self.log.error("Pod Event: %s - %s", event.reason, event.message)
+                if event.type == PodEventType.NORMAL.value:
+                    self.log.info("Pod Event: %s - %s", event.reason, event.message)
+                else:
+                    self.log.error("Pod Event: %s - %s", event.reason, event.message)
 
     def is_istio_enabled(self, pod: V1Pod) -> bool:
         """Check if istio is enabled for the namespace of the pod by inspecting the namespace labels."""
@@ -891,7 +910,7 @@ class KubernetesPodOperator(BaseOperator):
         self.log.info("Output of curl command to kill istio: %s", output_str)
         resp.close()
         if self.KILL_ISTIO_PROXY_SUCCESS_MSG not in output_str:
-            raise Exception("Error while deleting istio-proxy sidecar: %s", output_str)
+            raise AirflowException("Error while deleting istio-proxy sidecar: %s", output_str)
 
     def process_pod_deletion(self, pod: k8s.V1Pod, *, reraise=True):
         with _optionally_suppress(reraise=reraise):
@@ -1030,12 +1049,12 @@ class KubernetesPodOperator(BaseOperator):
         pod = PodGenerator.reconcile_pods(pod_template, pod)
 
         if not pod.metadata.name:
-            pod.metadata.name = create_pod_id(
+            pod.metadata.name = create_unique_id(
                 task_id=self.task_id, unique=self.random_name_suffix, max_length=POD_NAME_MAX_LENGTH
             )
         elif self.random_name_suffix:
             # user has supplied pod name, we're just adding suffix
-            pod.metadata.name = add_pod_suffix(pod_name=pod.metadata.name)
+            pod.metadata.name = add_unique_suffix(name=pod.metadata.name)
 
         if not pod.metadata.namespace:
             hook_namespace = self.hook.get_namespace()

airflow/providers/cncf/kubernetes/operators/resource.py

@@ -18,12 +18,14 @@
 
 from __future__ import annotations
 
+import os
 from functools import cached_property
-from typing import TYPE_CHECKING
+from typing import TYPE_CHECKING, Sequence
 
 import yaml
 from kubernetes.utils import create_from_yaml
 
+from airflow.exceptions import AirflowException
 from airflow.models import BaseOperator
 from airflow.providers.cncf.kubernetes.hooks.kubernetes import KubernetesHook
 from airflow.providers.cncf.kubernetes.utils.delete_from import delete_from_yaml
@@ -40,24 +42,29 @@ class KubernetesResourceBaseOperator(BaseOperator):
     Abstract base class for all Kubernetes Resource operators.
 
     :param yaml_conf: string. Contains the kubernetes resources to Create or Delete
+    :param yaml_conf_file: path to the kubernetes resources file (templated)
     :param namespace: string. Contains the namespace to create all resources inside.
         The namespace must preexist otherwise the resource creation will fail.
         If the API object in the yaml file already contains a namespace definition then
         this parameter has no effect.
     :param kubernetes_conn_id: The :ref:`kubernetes connection id <howto/connection:kubernetes>`
         for the Kubernetes cluster.
+    :param namespaced: specified that Kubernetes resource is or isn't in a namespace.
+        This parameter works only when custom_resource_definition parameter is True.
     """
 
-    template_fields = ("yaml_conf",)
+    template_fields: Sequence[str] = ("yaml_conf", "yaml_conf_file")
     template_fields_renderers = {"yaml_conf": "yaml"}
 
     def __init__(
         self,
         *,
-        yaml_conf: str,
+        yaml_conf: str | None = None,
+        yaml_conf_file: str | None = None,
         namespace: str | None = None,
         kubernetes_conn_id: str | None = KubernetesHook.default_conn_name,
         custom_resource_definition: bool = False,
+        namespaced: bool = True,
         config_file: str | None = None,
         **kwargs,
     ) -> None:
@@ -65,9 +72,14 @@ class KubernetesResourceBaseOperator(BaseOperator):
         self._namespace = namespace
         self.kubernetes_conn_id = kubernetes_conn_id
         self.yaml_conf = yaml_conf
+        self.yaml_conf_file = yaml_conf_file
         self.custom_resource_definition = custom_resource_definition
+        self.namespaced = namespaced
         self.config_file = config_file
 
+        if not any([self.yaml_conf, self.yaml_conf_file]):
+            raise AirflowException("One of `yaml_conf` or `yaml_conf_file` arguments must be provided")
+
     @cached_property
     def client(self) -> ApiClient:
         return self.hook.api_client
@@ -109,18 +121,29 @@ class KubernetesCreateResourceOperator(KubernetesResourceBaseOperator):
 
     def create_custom_from_yaml_object(self, body: dict):
         group, version, namespace, plural = self.get_crd_fields(body)
-        self.custom_object_client.create_namespaced_custom_object(group, version, namespace, plural, body)
+        if self.namespaced:
+            self.custom_object_client.create_namespaced_custom_object(group, version, namespace, plural, body)
+        else:
+            self.custom_object_client.create_cluster_custom_object(group, version, plural, body)
 
-    def execute(self, context) -> None:
-        resources = yaml.safe_load_all(self.yaml_conf)
+    def _create_objects(self, objects):
         if not self.custom_resource_definition:
             create_from_yaml(
                 k8s_client=self.client,
-                yaml_objects=resources,
+                yaml_objects=objects,
                 namespace=self.get_namespace(),
             )
         else:
-            k8s_resource_iterator(self.create_custom_from_yaml_object, resources)
+            k8s_resource_iterator(self.create_custom_from_yaml_object, objects)
+
+    def execute(self, context) -> None:
+        if self.yaml_conf:
+            self._create_objects(yaml.safe_load_all(self.yaml_conf))
+        elif self.yaml_conf_file and os.path.exists(self.yaml_conf_file):
+            with open(self.yaml_conf_file) as stream:
+                self._create_objects(yaml.safe_load_all(stream))
+        else:
+            raise AirflowException("File %s not found", self.yaml_conf_file)
 
 
 class KubernetesDeleteResourceOperator(KubernetesResourceBaseOperator):
@@ -129,15 +152,26 @@ class KubernetesDeleteResourceOperator(KubernetesResourceBaseOperator):
     def delete_custom_from_yaml_object(self, body: dict):
         name = body["metadata"]["name"]
         group, version, namespace, plural = self.get_crd_fields(body)
-        self.custom_object_client.delete_namespaced_custom_object(group, version, namespace, plural, name)
+        if self.namespaced:
+            self.custom_object_client.delete_namespaced_custom_object(group, version, namespace, plural, name)
+        else:
+            self.custom_object_client.delete_cluster_custom_object(group, version, plural, name)
 
-    def execute(self, context) -> None:
-        resources = yaml.safe_load_all(self.yaml_conf)
+    def _delete_objects(self, objects):
         if not self.custom_resource_definition:
             delete_from_yaml(
                 k8s_client=self.client,
-                yaml_objects=resources,
+                yaml_objects=objects,
                 namespace=self.get_namespace(),
             )
         else:
-            k8s_resource_iterator(self.delete_custom_from_yaml_object, resources)
+            k8s_resource_iterator(self.delete_custom_from_yaml_object, objects)
+
+    def execute(self, context) -> None:
+        if self.yaml_conf:
+            self._delete_objects(yaml.safe_load_all(self.yaml_conf))
+        elif self.yaml_conf_file and os.path.exists(self.yaml_conf_file):
+            with open(self.yaml_conf_file) as stream:
+                self._delete_objects(yaml.safe_load_all(stream))
+        else:
+            raise AirflowException("File %s not found", self.yaml_conf_file)

airflow/providers/cncf/kubernetes/operators/spark_kubernetes.py

@@ -19,6 +19,7 @@ from __future__ import annotations
 
 import re
 from functools import cached_property
+from pathlib import Path
 from typing import TYPE_CHECKING, Any
 
 from kubernetes.client import CoreV1Api, CustomObjectsApi, models as k8s
@@ -26,6 +27,7 @@ from kubernetes.client import CoreV1Api, CustomObjectsApi, models as k8s
 from airflow.exceptions import AirflowException
 from airflow.providers.cncf.kubernetes import pod_generator
 from airflow.providers.cncf.kubernetes.hooks.kubernetes import KubernetesHook, _load_body_to_dict
+from airflow.providers.cncf.kubernetes.kubernetes_helper_functions import add_unique_suffix
 from airflow.providers.cncf.kubernetes.operators.custom_object_launcher import CustomObjectLauncher
 from airflow.providers.cncf.kubernetes.operators.pod import KubernetesPodOperator
 from airflow.providers.cncf.kubernetes.pod_generator import MAX_LABEL_LEN, PodGenerator
@@ -71,6 +73,8 @@ class SparkKubernetesOperator(KubernetesPodOperator):
     template_ext = ("yaml", "yml", "json")
     ui_color = "#f4a460"
 
+    BASE_CONTAINER_NAME = "spark-kubernetes-driver"
+
     def __init__(
         self,
         *,
@@ -108,6 +112,18 @@ class SparkKubernetesOperator(KubernetesPodOperator):
         self.log_events_on_failure = log_events_on_failure
         self.success_run_history_limit = success_run_history_limit
 
+        if self.base_container_name != self.BASE_CONTAINER_NAME:
+            self.log.warning(
+                "base_container_name is not supported and will be overridden to %s", self.BASE_CONTAINER_NAME
+            )
+            self.base_container_name = self.BASE_CONTAINER_NAME
+
+        if self.get_logs and self.container_logs != self.BASE_CONTAINER_NAME:
+            self.log.warning(
+                "container_logs is not supported and will be overridden to %s", self.BASE_CONTAINER_NAME
+            )
+            self.container_logs = [self.BASE_CONTAINER_NAME]
+
     def _render_nested_template_fields(
         self,
         content: Any,
@@ -124,7 +140,16 @@ class SparkKubernetesOperator(KubernetesPodOperator):
 
     def manage_template_specs(self):
         if self.application_file:
-            template_body = _load_body_to_dict(open(self.application_file))
+            try:
+                filepath = Path(self.application_file.rstrip()).resolve(strict=True)
+            except (FileNotFoundError, OSError, RuntimeError, ValueError):
+                application_file_body = self.application_file
+            else:
+                application_file_body = filepath.read_text()
+            template_body = _load_body_to_dict(application_file_body)
+            if not isinstance(template_body, dict):
+                msg = f"application_file body can't transformed into the dictionary:\n{application_file_body}"
+                raise TypeError(msg)
         elif self.template_spec:
             template_body = self.template_spec
         else:
@@ -134,7 +159,7 @@ class SparkKubernetesOperator(KubernetesPodOperator):
         return template_body
 
     def create_job_name(self):
-        initial_name = PodGenerator.make_unique_pod_id(self.task_id)[:MAX_LABEL_LEN]
+        initial_name = add_unique_suffix(name=self.task_id, max_len=MAX_LABEL_LEN)
         return re.sub(r"[^a-z0-9-]+", "-", initial_name.lower())
 
     @staticmethod
@@ -263,7 +288,6 @@ class SparkKubernetesOperator(KubernetesPodOperator):
             template_body=self.template_body,
         )
         self.pod = self.get_or_create_spark_crd(self.launcher, context)
-        self.BASE_CONTAINER_NAME = "spark-kubernetes-driver"
         self.pod_request_obj = self.launcher.pod_spec
 
         return super().execute(context=context)

airflow/providers/cncf/kubernetes/pod_generator.py

@@ -22,6 +22,7 @@ API and outputs a kubernetes.client.models.V1Pod.
 The advantage being that the full Kubernetes API
 is supported and no serialization need be written.
 """
+
 from __future__ import annotations
 
 import copy
@@ -45,6 +46,7 @@ from airflow.exceptions import (
 from airflow.providers.cncf.kubernetes.kubernetes_helper_functions import (
     POD_NAME_MAX_LENGTH,
     add_pod_suffix,
+    add_unique_suffix,
     rand_str,
 )
 from airflow.providers.cncf.kubernetes.pod_generator_deprecated import (
@@ -396,7 +398,7 @@ class PodGenerator:
                 UserWarning,
                 stacklevel=2,
             )
-            pod_id = add_pod_suffix(pod_name=pod_id, max_len=POD_NAME_MAX_LENGTH)
+            pod_id = add_unique_suffix(name=pod_id, max_len=POD_NAME_MAX_LENGTH)
         try:
             image = pod_override_object.spec.containers[0].image  # type: ignore
             if not image:

airflow/providers/cncf/kubernetes/pod_generator_deprecated.py

@@ -22,6 +22,7 @@ API and outputs a kubernetes.client.models.V1Pod.
 The advantage being that the full Kubernetes API
 is supported and no serialization need be written.
 """
+
 from __future__ import annotations
 
 import copy

airflow/providers/cncf/kubernetes/pod_launcher_deprecated.py

@@ -15,6 +15,7 @@
 # specific language governing permissions and limitations
 # under the License.
 """Launches pods."""
+
 from __future__ import annotations
 
 import json

airflow/providers/cncf/kubernetes/python_kubernetes_script.py

@@ -16,6 +16,7 @@
 # specific language governing permissions and limitations
 # under the License.
 """Utilities for using the kubernetes decorator."""
+
 from __future__ import annotations
 
 import os

airflow/providers/cncf/kubernetes/secret.py

@@ -15,6 +15,7 @@
 # specific language governing permissions and limitations
 # under the License.
 """Classes for interacting with Kubernetes API."""
+
 from __future__ import annotations
 
 import copy

airflow/providers/cncf/kubernetes/triggers/job.py

@@ -0,0 +1,101 @@
+# 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.
+from __future__ import annotations
+
+from functools import cached_property
+from typing import TYPE_CHECKING, Any, AsyncIterator
+
+from airflow.providers.cncf.kubernetes.hooks.kubernetes import AsyncKubernetesHook
+from airflow.triggers.base import BaseTrigger, TriggerEvent
+
+if TYPE_CHECKING:
+    from kubernetes.client import V1Job
+
+
+class KubernetesJobTrigger(BaseTrigger):
+    """
+    KubernetesJobTrigger run on the trigger worker to check the state of Job.
+
+    :param job_name: The name of the job.
+    :param job_namespace: The namespace of the job.
+    :param kubernetes_conn_id: The :ref:`kubernetes connection id <howto/connection:kubernetes>`
+        for the Kubernetes cluster.
+    :param cluster_context: Context that points to kubernetes cluster.
+    :param config_file: Path to kubeconfig file.
+    :param poll_interval: Polling period in seconds to check for the status.
+    :param in_cluster: run kubernetes client with in_cluster configuration.
+    """
+
+    def __init__(
+        self,
+        job_name: str,
+        job_namespace: str,
+        kubernetes_conn_id: str | None = None,
+        poll_interval: float = 10.0,
+        cluster_context: str | None = None,
+        config_file: str | None = None,
+        in_cluster: bool | None = None,
+    ):
+        super().__init__()
+        self.job_name = job_name
+        self.job_namespace = job_namespace
+        self.kubernetes_conn_id = kubernetes_conn_id
+        self.poll_interval = poll_interval
+        self.cluster_context = cluster_context
+        self.config_file = config_file
+        self.in_cluster = in_cluster
+
+    def serialize(self) -> tuple[str, dict[str, Any]]:
+        """Serialize KubernetesCreateJobTrigger arguments and classpath."""
+        return (
+            "airflow.providers.cncf.kubernetes.triggers.job.KubernetesJobTrigger",
+            {
+                "job_name": self.job_name,
+                "job_namespace": self.job_namespace,
+                "kubernetes_conn_id": self.kubernetes_conn_id,
+                "poll_interval": self.poll_interval,
+                "cluster_context": self.cluster_context,
+                "config_file": self.config_file,
+                "in_cluster": self.in_cluster,
+            },
+        )
+
+    async def run(self) -> AsyncIterator[TriggerEvent]:  # type: ignore[override]
+        """Get current job status and yield a TriggerEvent."""
+        job: V1Job = await self.hook.wait_until_job_complete(name=self.job_name, namespace=self.job_namespace)
+        job_dict = job.to_dict()
+        error_message = self.hook.is_job_failed(job=job)
+        yield TriggerEvent(
+            {
+                "name": job.metadata.name,
+                "namespace": job.metadata.namespace,
+                "status": "error" if error_message else "success",
+                "message": f"Job failed with error: {error_message}"
+                if error_message
+                else "Job completed successfully",
+                "job": job_dict,
+            }
+        )
+
+    @cached_property
+    def hook(self) -> AsyncKubernetesHook:
+        return AsyncKubernetesHook(
+            conn_id=self.kubernetes_conn_id,
+            in_cluster=self.in_cluster,
+            config_file=self.config_file,
+            cluster_context=self.cluster_context,
+        )

airflow/providers/cncf/kubernetes/triggers/kubernetes_pod.py

@@ -16,6 +16,7 @@
 # specific language governing permissions and limitations
 # under the License.
 """This module is deprecated. Please use :mod:`airflow.providers.cncf.kubernetes.triggers.pod` instead."""
+
 from __future__ import annotations
 
 import warnings

airflow/providers/cncf/kubernetes/triggers/pod.py

@@ -67,6 +67,7 @@ class KubernetesPodTrigger(BaseTrigger):
     :param in_cluster: run kubernetes client with in_cluster configuration.
     :param get_logs: get the stdout of the container as logs of the tasks.
     :param startup_timeout: timeout in seconds to start up the pod.
+    :param startup_check_interval: interval in seconds to check if the pod has already started.
     :param on_finish_action: What to do when the pod reaches its final state, or the execution is interrupted.
         If "delete_pod", the pod will be deleted regardless its state; if "delete_succeeded_pod",
         only succeeded pod will be deleted. You can set to "keep_pod" to keep the pod.
@@ -92,7 +93,7 @@ class KubernetesPodTrigger(BaseTrigger):
         in_cluster: bool | None = None,
         get_logs: bool = True,
         startup_timeout: int = 120,
-        startup_check_interval: int = 1,
+        startup_check_interval: int = 5,
         on_finish_action: str = "delete_pod",
         should_delete_pod: bool | None = None,
         last_log_time: DateTime | None = None,
@@ -145,6 +146,7 @@ class KubernetesPodTrigger(BaseTrigger):
                 "in_cluster": self.in_cluster,
                 "get_logs": self.get_logs,
                 "startup_timeout": self.startup_timeout,
+                "startup_check_interval": self.startup_check_interval,
                 "trigger_start_time": self.trigger_start_time,
                 "should_delete_pod": self.should_delete_pod,
                 "on_finish_action": self.on_finish_action.value,
@@ -223,7 +225,7 @@ class KubernetesPodTrigger(BaseTrigger):
             if not pod.status.phase == "Pending":
                 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)
+            await asyncio.sleep(self.startup_check_interval)
             delta = datetime.datetime.now(tz=datetime.timezone.utc) - self.trigger_start_time
         raise PodLaunchTimeoutException("Pod did not leave 'Pending' phase within specified timeout")
 
@@ -243,7 +245,12 @@ class KubernetesPodTrigger(BaseTrigger):
             container_state = self.define_container_state(pod)
             if container_state == ContainerState.TERMINATED:
                 return TriggerEvent(
-                    {"status": "success", "namespace": self.pod_namespace, "name": self.pod_name}
+                    {
+                        "status": "success",
+                        "namespace": self.pod_namespace,
+                        "name": self.pod_name,
+                        "last_log_time": self.last_log_time,
+                    }
                 )
             elif container_state == ContainerState.FAILED:
                 return TriggerEvent(
@@ -252,6 +259,7 @@ class KubernetesPodTrigger(BaseTrigger):
                         "namespace": self.pod_namespace,
                         "name": self.pod_name,
                         "message": "Container state failed",
+                        "last_log_time": self.last_log_time,
                     }
                 )
             if time_get_more_logs and datetime.datetime.now(tz=datetime.timezone.utc) > time_get_more_logs:

airflow/providers/cncf/kubernetes/utils/pod_manager.py

@@ -15,6 +15,7 @@
 # specific language governing permissions and limitations
 # under the License.
 """Launches PODs."""
+
 from __future__ import annotations
 
 import enum
@@ -789,7 +790,7 @@ class PodManager(LoggingMixin):
                 _preload_content=False,
             )
         ) as resp:
-            self._exec_pod_command(resp, "kill -s SIGINT 1")
+            self._exec_pod_command(resp, "kill -2 1")
 
     def _exec_pod_command(self, resp, command: str) -> str | None:
         res = ""

airflow/providers/cncf/kubernetes/utils/xcom_sidecar.py

@@ -15,6 +15,7 @@
 # specific language governing permissions and limitations
 # under the License.
 """Attach a sidecar container that blocks the pod from completing until Airflow pulls result data."""
+
 from __future__ import annotations
 
 import copy