apache-airflow-providers-cncf-kubernetes 10.1.0rc2__py3-none-any.whl → 10.2.0__py3-none-any.whl

airflow/providers/cncf/kubernetes/LICENSE

@@ -199,55 +199,3 @@ 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.
-
-============================================================================
-   APACHE AIRFLOW SUBCOMPONENTS:
-
-   The Apache Airflow project contains subcomponents with separate copyright
-   notices and license terms. Your use of the source code for the these
-   subcomponents is subject to the terms and conditions of the following
-   licenses.
-
-
-========================================================================
-Third party Apache 2.0 licenses
-========================================================================
-
-The following components are provided under the Apache 2.0 License.
-See project link for details. The text of each license is also included
-at 3rd-party-licenses/LICENSE-[project].txt.
-
-    (ALv2 License) hue v4.3.0 (https://github.com/cloudera/hue/)
-    (ALv2 License) jqclock v2.3.0 (https://github.com/JohnRDOrazio/jQuery-Clock-Plugin)
-    (ALv2 License) bootstrap3-typeahead v4.0.2 (https://github.com/bassjobsen/Bootstrap-3-Typeahead)
-    (ALv2 License) connexion v2.7.0 (https://github.com/zalando/connexion)
-
-========================================================================
-MIT licenses
-========================================================================
-
-The following components are provided under the MIT License. See project link for details.
-The text of each license is also included at 3rd-party-licenses/LICENSE-[project].txt.
-
-    (MIT License) jquery v3.5.1 (https://jquery.org/license/)
-    (MIT License) dagre-d3 v0.6.4 (https://github.com/cpettitt/dagre-d3)
-    (MIT License) bootstrap v3.4.1 (https://github.com/twbs/bootstrap/)
-    (MIT License) d3-tip v0.9.1 (https://github.com/Caged/d3-tip)
-    (MIT License) dataTables v1.10.25 (https://datatables.net)
-    (MIT License) normalize.css v3.0.2 (http://necolas.github.io/normalize.css/)
-    (MIT License) ElasticMock v1.3.2 (https://github.com/vrcmarcos/elasticmock)
-    (MIT License) MomentJS v2.24.0 (http://momentjs.com/)
-    (MIT License) eonasdan-bootstrap-datetimepicker v4.17.49 (https://github.com/eonasdan/bootstrap-datetimepicker/)
-
-========================================================================
-BSD 3-Clause licenses
-========================================================================
-The following components are provided under the BSD 3-Clause license. See project links for details.
-The text of each license is also included at 3rd-party-licenses/LICENSE-[project].txt.
-
-    (BSD 3 License) d3 v5.16.0 (https://d3js.org)
-    (BSD 3 License) d3-shape v2.1.0 (https://github.com/d3/d3-shape)
-    (BSD 3 License) cgroupspy 0.2.1 (https://github.com/cloudsigma/cgroupspy)
-
-========================================================================
-See 3rd-party-licenses/LICENSES-ui.txt for packages used in `/airflow/www`

airflow/providers/cncf/kubernetes/__init__.py

@@ -29,7 +29,7 @@ from airflow import __version__ as airflow_version
 
 __all__ = ["__version__"]
 
-__version__ = "10.1.0"
+__version__ = "10.2.0"
 
 if packaging.version.parse(packaging.version.parse(airflow_version).base_version) < packaging.version.parse(
     "2.9.0"

airflow/providers/cncf/kubernetes/backcompat/backwards_compat_converters.py

@@ -18,9 +18,8 @@
 
 from __future__ import annotations
 
-from kubernetes.client import ApiClient, models as k8s
-
 from airflow.exceptions import AirflowException
+from kubernetes.client import ApiClient, models as k8s
 
 
 def _convert_kube_model_object(obj, new_class):
@@ -74,7 +73,7 @@ def convert_env_vars(env_vars: list[k8s.V1EnvVar] | dict[str, str]) -> list[k8s.
     """
     Coerce env var collection for kubernetes.
 
-    If the collection is a str-str dict, convert it into a list of ``V1EnvVar``s.
+    If the collection is a str-str dict, convert it into a list of ``V1EnvVar`` variables.
     """
     if isinstance(env_vars, dict):
         return [k8s.V1EnvVar(name=k, value=v) for k, v in env_vars.items()]

airflow/providers/cncf/kubernetes/callbacks.py

@@ -17,11 +17,16 @@
 from __future__ import annotations
 
 from enum import Enum
-from typing import Union
+from typing import TYPE_CHECKING, Union
 
-import kubernetes.client as k8s
 import kubernetes_asyncio.client as async_k8s
 
+import kubernetes.client as k8s
+
+if TYPE_CHECKING:
+    from airflow.providers.cncf.kubernetes.operators.pod import KubernetesPodOperator
+    from airflow.utils.context import Context
+
 client_type = Union[k8s.CoreV1Api, async_k8s.CoreV1Api]
 
 
@@ -41,7 +46,7 @@ class KubernetesPodOperatorCallback:
     """
 
     @staticmethod
-    def on_sync_client_creation(*, client: k8s.CoreV1Api, **kwargs) -> None:
+    def on_sync_client_creation(*, client: k8s.CoreV1Api, operator: KubernetesPodOperator, **kwargs) -> None:
         """
         Invoke this callback after creating the sync client.
 
@@ -50,7 +55,34 @@ class KubernetesPodOperatorCallback:
         pass
 
     @staticmethod
-    def on_pod_creation(*, pod: k8s.V1Pod, client: client_type, mode: str, **kwargs) -> None:
+    def on_pod_manifest_created(
+        *,
+        pod_request: k8s.V1Pod,
+        client: client_type,
+        mode: str,
+        operator: KubernetesPodOperator,
+        context: Context,
+        **kwargs,
+    ) -> None:
+        """
+        Invoke this callback after KPO creates the V1Pod manifest but before the pod is created.
+
+        :param pod_request: the kubernetes pod manifest
+        :param client: the Kubernetes client that can be used in the callback.
+        :param mode: the current execution mode, it's one of (`sync`, `async`).
+        """
+        pass
+
+    @staticmethod
+    def on_pod_creation(
+        *,
+        pod: k8s.V1Pod,
+        client: client_type,
+        mode: str,
+        operator: KubernetesPodOperator,
+        context: Context,
+        **kwargs,
+    ) -> None:
         """
         Invoke this callback after creating the pod.
 
@@ -61,7 +93,15 @@ class KubernetesPodOperatorCallback:
         pass
 
     @staticmethod
-    def on_pod_starting(*, pod: k8s.V1Pod, client: client_type, mode: str, **kwargs) -> None:
+    def on_pod_starting(
+        *,
+        pod: k8s.V1Pod,
+        client: client_type,
+        mode: str,
+        operator: KubernetesPodOperator,
+        context: Context,
+        **kwargs,
+    ) -> None:
         """
         Invoke this callback when the pod starts.
 
@@ -72,7 +112,15 @@ class KubernetesPodOperatorCallback:
         pass
 
     @staticmethod
-    def on_pod_completion(*, pod: k8s.V1Pod, client: client_type, mode: str, **kwargs) -> None:
+    def on_pod_completion(
+        *,
+        pod: k8s.V1Pod,
+        client: client_type,
+        mode: str,
+        operator: KubernetesPodOperator,
+        context: Context,
+        **kwargs,
+    ) -> None:
         """
         Invoke this callback when the pod completes.
 
@@ -83,7 +131,34 @@ class KubernetesPodOperatorCallback:
         pass
 
     @staticmethod
-    def on_pod_cleanup(*, pod: k8s.V1Pod, client: client_type, mode: str, **kwargs):
+    def on_pod_teardown(
+        *,
+        pod: k8s.V1Pod,
+        client: client_type,
+        mode: str,
+        operator: KubernetesPodOperator,
+        context: Context,
+        **kwargs,
+    ) -> None:
+        """
+        Invoke this callback after all pod completion callbacks but before the pod is deleted.
+
+        :param pod: the completed pod.
+        :param client: the Kubernetes client that can be used in the callback.
+        :param mode: the current execution mode, it's one of (`sync`, `async`).
+        """
+        pass
+
+    @staticmethod
+    def on_pod_cleanup(
+        *,
+        pod: k8s.V1Pod,
+        client: client_type,
+        mode: str,
+        operator: KubernetesPodOperator,
+        context: Context,
+        **kwargs,
+    ):
         """
         Invoke this callback after cleaning/deleting the pod.
 
@@ -95,7 +170,14 @@ class KubernetesPodOperatorCallback:
 
     @staticmethod
     def on_operator_resuming(
-        *, pod: k8s.V1Pod, event: dict, client: client_type, mode: str, **kwargs
+        *,
+        pod: k8s.V1Pod,
+        event: dict,
+        client: client_type,
+        mode: str,
+        operator: KubernetesPodOperator,
+        context: Context,
+        **kwargs,
     ) -> None:
         """
         Invoke this callback when resuming the `KubernetesPodOperator` from deferred state.

airflow/providers/cncf/kubernetes/cli/kubernetes_command.py

@@ -22,10 +22,6 @@ import os
 import sys
 from datetime import datetime, timedelta
 
-from kubernetes import client
-from kubernetes.client.api_client import ApiClient
-from kubernetes.client.rest import ApiException
-
 from airflow.models import DagRun, TaskInstance
 from airflow.providers.cncf.kubernetes import pod_generator
 from airflow.providers.cncf.kubernetes.executors.kubernetes_executor import KubeConfig
@@ -36,6 +32,9 @@ from airflow.providers.cncf.kubernetes.version_compat import AIRFLOW_V_3_0_PLUS
 from airflow.utils import cli as cli_utils, yaml
 from airflow.utils.cli import get_dag
 from airflow.utils.providers_configuration_loader import providers_configuration_loaded
+from kubernetes import client
+from kubernetes.client.api_client import ApiClient
+from kubernetes.client.rest import ApiException
 
 
 @cli_utils.action_cli

airflow/providers/cncf/kubernetes/decorators/kubernetes.py

@@ -19,20 +19,19 @@ from __future__ import annotations
 import base64
 import os
 import pickle
-import uuid
 from collections.abc import Sequence
 from shlex import quote
 from tempfile import TemporaryDirectory
 from typing import TYPE_CHECKING, Callable
 
 import dill
-from kubernetes.client import models as k8s
 
 from airflow.decorators.base import DecoratedOperator, TaskDecorator, task_decorator_factory
 from airflow.providers.cncf.kubernetes.operators.pod import KubernetesPodOperator
 from airflow.providers.cncf.kubernetes.python_kubernetes_script import (
     write_python_script,
 )
+from kubernetes.client import models as k8s
 
 if TYPE_CHECKING:
     from airflow.utils.context import Context
@@ -68,9 +67,15 @@ class _KubernetesDecoratedOperator(DecoratedOperator, KubernetesPodOperator):
 
     def __init__(self, namespace: str | None = None, use_dill: bool = False, **kwargs) -> None:
         self.use_dill = use_dill
+
+        # If the name was not provided, we generate operator name from the python_callable
+        # we also instruct operator to add a random suffix to avoid collisions by default
+        op_name = kwargs.pop("name", f"k8s-airflow-pod-{kwargs['python_callable'].__name__}")
+        random_name_suffix = kwargs.pop("random_name_suffix", True)
         super().__init__(
             namespace=namespace,
-            name=kwargs.pop("name", f"k8s_airflow_pod_{uuid.uuid4().hex}"),
+            name=op_name,
+            random_name_suffix=random_name_suffix,
             cmds=["placeholder-command"],
             **kwargs,
         )
@@ -119,7 +124,7 @@ class _KubernetesDecoratedOperator(DecoratedOperator, KubernetesPodOperator):
             }
             write_python_script(jinja_context=jinja_context, filename=script_filename)
 
-            self.env_vars = [
+            self.env_vars: list[k8s.V1EnvVar] = [
                 *self.env_vars,
                 k8s.V1EnvVar(name=_PYTHON_SCRIPT_ENV, value=_read_file_contents(script_filename)),
                 k8s.V1EnvVar(name=_PYTHON_INPUT_ENV, value=_read_file_contents(input_filename)),
@@ -138,7 +143,7 @@ def kubernetes_task(
     Kubernetes operator decorator.
 
     This wraps a function to be executed in K8s using KubernetesPodOperator.
-    Also accepts any argument that DockerOperator will via ``kwargs``. Can be
+    Also accepts any argument that KubernetesPodOperator will via ``kwargs``. Can be
     reused in a single DAG.
 
     :param python_callable: Function to decorate

airflow/providers/cncf/kubernetes/exceptions.py

@@ -0,0 +1,29 @@
+# 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 airflow.exceptions import (
+    AirflowException,
+)
+
+
+class PodMutationHookException(AirflowException):
+    """Raised when exception happens during Pod Mutation Hook execution."""
+
+
+class PodReconciliationError(AirflowException):
+    """Raised when an error is encountered while trying to merge pod configs."""

airflow/providers/cncf/kubernetes/executors/kubernetes_executor.py

@@ -37,8 +37,11 @@ from queue import Empty, Queue
 from typing import TYPE_CHECKING, Any
 
 from deprecated import deprecated
+from sqlalchemy import select
+
+from airflow.providers.cncf.kubernetes.pod_generator import PodGenerator
+from airflow.providers.cncf.kubernetes.version_compat import AIRFLOW_V_3_0_PLUS
 from kubernetes.dynamic import DynamicClient
-from sqlalchemy import or_, select, update
 
 try:
     from airflow.cli.cli_config import ARG_LOGICAL_DATE
@@ -60,16 +63,14 @@ from airflow.cli.cli_config import (
 from airflow.configuration import conf
 from airflow.exceptions import AirflowProviderDeprecationWarning
 from airflow.executors.base_executor import BaseExecutor
-from airflow.executors.executor_constants import KUBERNETES_EXECUTOR
+from airflow.providers.cncf.kubernetes.exceptions import PodMutationHookException, PodReconciliationError
 from airflow.providers.cncf.kubernetes.executors.kubernetes_executor_types import (
     ADOPTED,
     POD_EXECUTOR_DONE_KEY,
 )
 from airflow.providers.cncf.kubernetes.kube_config import KubeConfig
 from airflow.providers.cncf.kubernetes.kubernetes_helper_functions import annotations_to_key
-from airflow.providers.cncf.kubernetes.pod_generator import PodMutationHookException, PodReconciliationError
 from airflow.stats import Stats
-from airflow.utils.event_scheduler import EventScheduler
 from airflow.utils.log.logging_mixin import remove_escape_codes
 from airflow.utils.session import NEW_SESSION, provide_session
 from airflow.utils.state import TaskInstanceState
@@ -77,10 +78,9 @@ from airflow.utils.state import TaskInstanceState
 if TYPE_CHECKING:
     import argparse
 
-    from kubernetes import client
-    from kubernetes.client import models as k8s
     from sqlalchemy.orm import Session
 
+    from airflow.executors import workloads
     from airflow.executors.base_executor import CommandType
     from airflow.models.taskinstance import TaskInstance
     from airflow.models.taskinstancekey import TaskInstanceKey
@@ -91,6 +91,8 @@ if TYPE_CHECKING:
     from airflow.providers.cncf.kubernetes.executors.kubernetes_executor_utils import (
         AirflowKubernetesScheduler,
     )
+    from kubernetes import client
+    from kubernetes.client import models as k8s
 
 # CLI Args
 ARG_NAMESPACE = Arg(
@@ -137,6 +139,11 @@ class KubernetesExecutor(BaseExecutor):
     RUNNING_POD_LOG_LINES = 100
     supports_ad_hoc_ti_run: bool = True
 
+    if TYPE_CHECKING and AIRFLOW_V_3_0_PLUS:
+        # In the v3 path, we store workloads, not commands as strings.
+        # TODO: TaskSDK: move this type change into BaseExecutor
+        queued_tasks: dict[TaskInstanceKey, workloads.All]  # type: ignore[assignment]
+
     def __init__(self):
         self.kube_config = KubeConfig()
         self._manager = multiprocessing.Manager()
@@ -145,7 +152,6 @@ class KubernetesExecutor(BaseExecutor):
         self.kube_scheduler: AirflowKubernetesScheduler | None = None
         self.kube_client: client.CoreV1Api | None = None
         self.scheduler_job_id: str | None = None
-        self.event_scheduler: EventScheduler | None = None
         self.last_handled: dict[TaskInstanceKey, float] = {}
         self.kubernetes_queue: str | None = None
         self.task_publish_retries: Counter[TaskInstanceKey] = Counter()
@@ -218,96 +224,6 @@ class KubernetesExecutor(BaseExecutor):
                 pod_combined_search_str_to_pod_map[search_str] = pod
         return pod_combined_search_str_to_pod_map
 
-    @provide_session
-    def clear_not_launched_queued_tasks(self, session: Session = NEW_SESSION) -> None:
-        """
-        Clear tasks that were not yet launched, but were previously queued.
-
-        Tasks can end up in a "Queued" state when a rescheduled/deferred operator
-        comes back up for execution (with the same try_number) before the
-        pod of its previous incarnation has been fully removed (we think).
-
-        It's also possible when an executor abruptly shuts down (leaving a non-empty
-        task_queue on that executor), but that scenario is handled via normal adoption.
-
-        This method checks each of our queued tasks to see if the corresponding pod
-        is around, and if not, and there's no matching entry in our own
-        task_queue, marks it for re-execution.
-        """
-        if TYPE_CHECKING:
-            assert self.kube_client
-        from airflow.models.taskinstance import TaskInstance
-
-        hybrid_executor_enabled = hasattr(TaskInstance, "executor")
-        default_executor_alias = None
-        if hybrid_executor_enabled:
-            from airflow.executors.executor_loader import ExecutorLoader
-
-            default_executor_name = ExecutorLoader.get_default_executor_name()
-            default_executor_alias = default_executor_name.alias
-
-        with Stats.timer("kubernetes_executor.clear_not_launched_queued_tasks.duration"):
-            self.log.debug("Clearing tasks that have not been launched")
-            query = select(TaskInstance).where(
-                TaskInstance.state == TaskInstanceState.QUEUED,
-                TaskInstance.queued_by_job_id == self.job_id,
-            )
-            if self.kubernetes_queue:
-                query = query.where(TaskInstance.queue == self.kubernetes_queue)
-            # KUBERNETES_EXECUTOR is the string name/alias of the "core" executor represented by this
-            # module. The ExecutorName for "core" executors always contains an alias and cannot be modified
-            # to be different from the constant (in this case KUBERNETES_EXECUTOR).
-            elif hybrid_executor_enabled and default_executor_alias == KUBERNETES_EXECUTOR:
-                query = query.where(
-                    or_(
-                        TaskInstance.executor == KUBERNETES_EXECUTOR,
-                        TaskInstance.executor.is_(None),
-                    ),
-                )
-            elif hybrid_executor_enabled:
-                query = query.where(TaskInstance.executor == KUBERNETES_EXECUTOR)
-            queued_tis: list[TaskInstance] = session.scalars(query).all()
-            self.log.info("Found %s queued task instances", len(queued_tis))
-
-            # Go through the "last seen" dictionary and clean out old entries
-            allowed_age = self.kube_config.worker_pods_queued_check_interval * 3
-            for key, timestamp in list(self.last_handled.items()):
-                if time.time() - timestamp > allowed_age:
-                    del self.last_handled[key]
-
-            if not queued_tis:
-                return
-
-            pod_combined_search_str_to_pod_map = self.get_pod_combined_search_str_to_pod_map()
-
-            for ti in queued_tis:
-                self.log.debug("Checking task instance %s", ti)
-
-                # Check to see if we've handled it ourselves recently
-                if ti.key in self.last_handled:
-                    continue
-
-                # Build the pod selector
-                base_selector = f"dag_id={ti.dag_id},task_id={ti.task_id}"
-                if ti.map_index >= 0:
-                    # Old tasks _couldn't_ be mapped, so we don't have to worry about compat
-                    base_selector += f",map_index={ti.map_index}"
-
-                search_str = f"{base_selector},run_id={ti.run_id}"
-                if search_str in pod_combined_search_str_to_pod_map:
-                    continue
-                self.log.info("TaskInstance: %s found in queued state but was not launched, rescheduling", ti)
-                session.execute(
-                    update(TaskInstance)
-                    .where(
-                        TaskInstance.dag_id == ti.dag_id,
-                        TaskInstance.task_id == ti.task_id,
-                        TaskInstance.run_id == ti.run_id,
-                        TaskInstance.map_index == ti.map_index,
-                    )
-                    .values(state=TaskInstanceState.SCHEDULED)
-                )
-
     def start(self) -> None:
         """Start the executor."""
         self.log.info("Start Kubernetes executor")
@@ -325,15 +241,6 @@ class KubernetesExecutor(BaseExecutor):
             kube_client=self.kube_client,
             scheduler_job_id=self.scheduler_job_id,
         )
-        self.event_scheduler = EventScheduler()
-
-        self.event_scheduler.call_regular_interval(
-            self.kube_config.worker_pods_queued_check_interval,
-            self.clear_not_launched_queued_tasks,
-        )
-        # We also call this at startup as that's the most likely time to see
-        # stuck queued tasks
-        self.clear_not_launched_queued_tasks()
 
     def execute_async(
         self,
@@ -351,8 +258,6 @@ class KubernetesExecutor(BaseExecutor):
         else:
             self.log.info("Add task %s with command %s", key, command)
 
-        from airflow.providers.cncf.kubernetes.pod_generator import PodGenerator
-
         try:
             kube_executor_config = PodGenerator.from_obj(executor_config)
         except Exception:
@@ -370,6 +275,29 @@ class KubernetesExecutor(BaseExecutor):
         # try and remove it from the QUEUED state while we process it
         self.last_handled[key] = time.time()
 
+    def queue_workload(self, workload: workloads.All, session: Session | None) -> None:
+        from airflow.executors import workloads
+
+        if not isinstance(workload, workloads.ExecuteTask):
+            raise RuntimeError(f"{type(self)} cannot handle workloads of type {type(workload)}")
+        ti = workload.ti
+        self.queued_tasks[ti.key] = workload
+
+    def _process_workloads(self, workloads: list[workloads.All]) -> None:
+        # Airflow V3 version
+        for w in workloads:
+            # TODO: AIP-72 handle populating tokens once https://github.com/apache/airflow/issues/45107 is handled.
+            command = [w]
+            key = w.ti.key  # type: ignore[union-attr]
+            queue = w.ti.queue  # type: ignore[union-attr]
+
+            # TODO: will be handled by https://github.com/apache/airflow/issues/46892
+            executor_config = {}  # type: ignore[var-annotated]
+
+            del self.queued_tasks[key]
+            self.execute_async(key=key, command=command, queue=queue, executor_config=executor_config)  # type: ignore[arg-type]
+            self.running.add(key)
+
     def sync(self) -> None:
         """Synchronize task state."""
         if TYPE_CHECKING:
@@ -378,7 +306,6 @@ class KubernetesExecutor(BaseExecutor):
             assert self.kube_config
             assert self.result_queue
             assert self.task_queue
-            assert self.event_scheduler
 
         if self.running:
             self.log.debug("self.running: %s", self.running)
@@ -466,10 +393,6 @@ class KubernetesExecutor(BaseExecutor):
                 finally:
                     self.task_queue.task_done()
 
-        # Run any pending timed events
-        next_event = self.event_scheduler.run(blocking=False)
-        self.log.debug("Next timed event is in %f", next_event)
-
     @provide_session
     def _change_state(
         self,

airflow/providers/cncf/kubernetes/executors/kubernetes_executor_utils.py

@@ -23,8 +23,6 @@ import time
 from queue import Empty, Queue
 from typing import TYPE_CHECKING, Any
 
-from kubernetes import client, watch
-from kubernetes.client.rest import ApiException
 from urllib3.exceptions import ReadTimeoutError
 
 from airflow.exceptions import AirflowException
@@ -45,15 +43,16 @@ from airflow.providers.cncf.kubernetes.pod_generator import PodGenerator
 from airflow.utils.log.logging_mixin import LoggingMixin
 from airflow.utils.singleton import Singleton
 from airflow.utils.state import TaskInstanceState
+from kubernetes import client, watch
+from kubernetes.client.rest import ApiException
 
 if TYPE_CHECKING:
-    from kubernetes.client import Configuration, models as k8s
-
     from airflow.providers.cncf.kubernetes.executors.kubernetes_executor_types import (
         KubernetesJobType,
         KubernetesResultsType,
         KubernetesWatchType,
     )
+    from kubernetes.client import Configuration, models as k8s
 
 
 class ResourceVersion(metaclass=Singleton):
@@ -147,10 +146,10 @@ class KubernetesJobWatcher(multiprocessing.Process, LoggingMixin):
         # For info about k8s timeout settings see
         # https://github.com/kubernetes-client/python/blob/v29.0.0/examples/watch/timeout-settings.md
         # and https://github.com/kubernetes-client/python/blob/v29.0.0/kubernetes/client/api_client.py#L336-L339
-        client_timeout = 30
-        server_conn_timeout = 3600
-        kwargs["_request_timeout"] = client_timeout
-        kwargs["timeout_seconds"] = server_conn_timeout
+        if "_request_timeout" not in kwargs:
+            kwargs["_request_timeout"] = 30
+        if "timeout_seconds" not in kwargs:
+            kwargs["timeout_seconds"] = 3600
 
         logical_date_key = get_logical_date_key()
         for event in self._pod_events(kube_client=kube_client, query_kwargs=kwargs):
@@ -231,12 +230,8 @@ class KubernetesJobWatcher(multiprocessing.Process, LoggingMixin):
             )
         elif status == "Pending":
             # deletion_timestamp is set by kube server when a graceful deletion is requested.
-            # since kube server have received request to delete pod set TI state failed
             if event["type"] == "DELETED" and pod.metadata.deletion_timestamp:
                 self.log.info("Event: Failed to start pod %s, annotations: %s", pod_name, annotations_string)
-                self.watcher_queue.put(
-                    (pod_name, namespace, TaskInstanceState.FAILED, annotations, resource_version)
-                )
             elif (
                 self.kube_config.worker_pod_pending_fatal_container_state_reasons
                 and "status" in event["raw_object"]
@@ -393,8 +388,24 @@ class AirflowKubernetesScheduler(LoggingMixin):
         key, command, kube_executor_config, pod_template_file = next_job
 
         dag_id, task_id, run_id, try_number, map_index = key
-
-        if command[0:3] != ["airflow", "tasks", "run"]:
+        ser_input = ""
+        if len(command) == 1:
+            from airflow.executors.workloads import ExecuteTask
+
+            if isinstance(command[0], ExecuteTask):
+                workload = command[0]
+                ser_input = workload.model_dump_json()
+                command = [
+                    "python",
+                    "-m",
+                    "airflow.sdk.execution_time.execute_workload",
+                    "/tmp/execute/input.json",
+                ]
+            else:
+                raise ValueError(
+                    f"KubernetesExecutor doesn't know how to handle workload of type: {type(command[0])}"
+                )
+        elif command[0:3] != ["airflow", "tasks", "run"]:
             raise ValueError('The command must start with ["airflow", "tasks", "run"].')
 
         base_worker_pod = get_base_pod_from_template(pod_template_file, self.kube_config)
@@ -415,7 +426,8 @@ class AirflowKubernetesScheduler(LoggingMixin):
             map_index=map_index,
             date=None,
             run_id=run_id,
-            args=command,
+            args=list(command),
+            content_json_for_volume=ser_input,
             pod_override_object=kube_executor_config,
             base_worker_pod=base_worker_pod,
             with_mutation_hook=True,