apache-airflow-providers-edge3 1.5.0__py3-none-any.whl → 2.0.0__py3-none-any.whl

airflow/providers/edge3/__init__.py

@@ -29,11 +29,11 @@ from airflow import __version__ as airflow_version
 
 __all__ = ["__version__"]
 
-__version__ = "1.5.0"
+__version__ = "2.0.0"
 
 if packaging.version.parse(packaging.version.parse(airflow_version).base_version) < packaging.version.parse(
-    "2.10.0"
+    "3.0.0"
 ):
     raise RuntimeError(
-        f"The package `apache-airflow-providers-edge3:{__version__}` needs Apache Airflow 2.10.0+"
+        f"The package `apache-airflow-providers-edge3:{__version__}` needs Apache Airflow 3.0.0+"
     )

airflow/providers/edge3/cli/api_client.py

@@ -20,6 +20,7 @@ import json
 import logging
 import os
 from datetime import datetime
+from functools import cache
 from http import HTTPStatus
 from pathlib import Path
 from typing import TYPE_CHECKING, Any
@@ -27,11 +28,14 @@ from urllib.parse import quote, urljoin
 
 import requests
 from retryhttp import retry, wait_retry_after
-from tenacity import before_log, wait_random_exponential
+from tenacity import before_sleep_log, wait_random_exponential
 
+from airflow.api_fastapi.auth.tokens import JWTGenerator
 from airflow.configuration import conf
-from airflow.providers.edge3.models.edge_worker import EdgeWorkerVersionException
-from airflow.providers.edge3.version_compat import AIRFLOW_V_3_0_PLUS
+from airflow.providers.edge3.models.edge_worker import (
+    EdgeWorkerDuplicateException,
+    EdgeWorkerVersionException,
+)
 from airflow.providers.edge3.worker_api.datamodels import (
     EdgeJobFetched,
     PushLogsBody,
@@ -71,6 +75,15 @@ API_RETRY_WAIT_MAX = float(
 _default_wait = wait_random_exponential(min=API_RETRY_WAIT_MIN, max=API_RETRY_WAIT_MAX)
 
 
+@cache
+def jwt_generator() -> JWTGenerator:
+    return JWTGenerator(
+        secret_key=conf.get("api_auth", "jwt_secret"),
+        valid_for=conf.getint("api_auth", "jwt_leeway", fallback=30),
+        audience="api",
+    )
+
+
 @retry(
     reraise=True,
     max_attempt_number=API_RETRIES,
@@ -78,31 +91,10 @@ _default_wait = wait_random_exponential(min=API_RETRY_WAIT_MIN, max=API_RETRY_WA
     wait_network_errors=_default_wait,
     wait_timeouts=_default_wait,
     wait_rate_limited=wait_retry_after(fallback=_default_wait),  # No infinite timeout on HTTP 429
-    before_sleep=before_log(logger, logging.WARNING),
+    before_sleep=before_sleep_log(logger, logging.WARNING),
 )
 def _make_generic_request(method: str, rest_path: str, data: str | None = None) -> Any:
-    if AIRFLOW_V_3_0_PLUS:
-        from functools import cache
-
-        from airflow.api_fastapi.auth.tokens import JWTGenerator
-
-        @cache
-        def jwt_generator() -> JWTGenerator:
-            return JWTGenerator(
-                secret_key=conf.get("api_auth", "jwt_secret"),
-                valid_for=conf.getint("api_auth", "jwt_leeway", fallback=30),
-                audience="api",
-            )
-
-        generator = jwt_generator()
-        authorization = generator.generate({"method": rest_path})
-    else:
-        # Airflow 2.10 compatibility
-        from airflow.providers.edge3.worker_api.auth import jwt_signer
-
-        signer = jwt_signer()
-        authorization = signer.generate_signed_token({"method": rest_path})
-
+    authorization = jwt_generator().generate({"method": rest_path})
     api_url = conf.get("edge", "api_url")
     headers = {
         "Content-Type": "application/json",
@@ -132,6 +124,11 @@ def worker_register(
     except requests.HTTPError as e:
         if e.response.status_code == 400:
             raise EdgeWorkerVersionException(str(e))
+        if e.response.status_code == 409:
+            raise EdgeWorkerDuplicateException(
+                f"A worker with the name '{hostname}' is already active. "
+                "Please ensure worker names are unique, or stop the existing worker before starting a new one."
+            )
         raise e
     return WorkerRegistrationReturn(**result)
 

airflow/providers/edge3/cli/worker.py

@@ -25,7 +25,6 @@ from functools import cache
 from http import HTTPStatus
 from multiprocessing import Process
 from pathlib import Path
-from subprocess import Popen
 from time import sleep
 from typing import TYPE_CHECKING
 
@@ -39,7 +38,6 @@ from airflow.providers.edge3 import __version__ as edge_provider_version
 from airflow.providers.edge3.cli.api_client import (
     jobs_fetch,
     jobs_set_state,
-    logs_logfile_path,
     logs_push,
     worker_register,
     worker_set_state,
@@ -51,8 +49,11 @@ from airflow.providers.edge3.cli.signalling import (
     status_file_path,
     write_pid_to_pidfile,
 )
-from airflow.providers.edge3.models.edge_worker import EdgeWorkerState, EdgeWorkerVersionException
-from airflow.providers.edge3.version_compat import AIRFLOW_V_3_0_PLUS
+from airflow.providers.edge3.models.edge_worker import (
+    EdgeWorkerDuplicateException,
+    EdgeWorkerState,
+    EdgeWorkerVersionException,
+)
 from airflow.utils.net import getfqdn
 from airflow.utils.state import TaskInstanceState
 
@@ -214,7 +215,7 @@ class EdgeWorker:
             return 1
 
     @staticmethod
-    def _launch_job_af3(edge_job: EdgeJobFetched) -> tuple[Process, Path]:
+    def _launch_job(edge_job: EdgeJobFetched):
         if TYPE_CHECKING:
             from airflow.executors.workloads import ExecuteTask
 
@@ -228,29 +229,6 @@ class EdgeWorker:
         if TYPE_CHECKING:
             assert workload.log_path  # We need to assume this is defined in here
         logfile = Path(base_log_folder, workload.log_path)
-        return process, logfile
-
-    @staticmethod
-    def _launch_job_af2_10(edge_job: EdgeJobFetched) -> tuple[Popen, Path]:
-        """Compatibility for Airflow 2.10 Launch."""
-        env = os.environ.copy()
-        env["AIRFLOW__CORE__DATABASE_ACCESS_ISOLATION"] = "True"
-        env["AIRFLOW__CORE__INTERNAL_API_URL"] = conf.get("edge", "api_url")
-        env["_AIRFLOW__SKIP_DATABASE_EXECUTOR_COMPATIBILITY_CHECK"] = "1"
-        command: list[str] = edge_job.command  # type: ignore[assignment]
-        process = Popen(command, close_fds=True, env=env, start_new_session=True)
-        logfile = logs_logfile_path(edge_job.key)
-        return process, logfile
-
-    @staticmethod
-    def _launch_job(edge_job: EdgeJobFetched):
-        """Get the received job executed."""
-        process: Popen | Process
-        if AIRFLOW_V_3_0_PLUS:
-            process, logfile = EdgeWorker._launch_job_af3(edge_job)
-        else:
-            # Airflow 2.10
-            process, logfile = EdgeWorker._launch_job_af2_10(edge_job)
         EdgeWorker.jobs.append(Job(edge_job, process, logfile, 0))
 
     def start(self):
@@ -262,6 +240,9 @@ class EdgeWorker:
         except EdgeWorkerVersionException as e:
             logger.info("Version mismatch of Edge worker and Core. Shutting down worker.")
             raise SystemExit(str(e))
+        except EdgeWorkerDuplicateException as e:
+            logger.error(str(e))
+            raise SystemExit(str(e))
         except HTTPError as e:
             if e.response.status_code == HTTPStatus.NOT_FOUND:
                 raise SystemExit("Error: API endpoint is not ready, please set [edge] api_enabled=True.")

airflow/providers/edge3/example_dags/integration_test.py

@@ -26,7 +26,7 @@ from __future__ import annotations
 from datetime import datetime
 from time import sleep
 
-from airflow.exceptions import AirflowNotFoundException
+from airflow.providers.common.compat.sdk import AirflowNotFoundException
 
 try:
     from airflow.sdk import BaseHook

airflow/providers/edge3/example_dags/win_test.py

@@ -32,42 +32,52 @@ from subprocess import STDOUT, Popen
 from time import sleep
 from typing import TYPE_CHECKING, Any
 
-try:
-    from airflow.sdk import task, task_group
-except ImportError:
-    # Airflow 2 path
-    from airflow.decorators import task, task_group  # type: ignore[attr-defined,no-redef]
-from airflow.exceptions import AirflowException, AirflowNotFoundException, AirflowSkipException
 from airflow.models import BaseOperator
 from airflow.models.dag import DAG
 from airflow.models.variable import Variable
+from airflow.providers.common.compat.sdk import (
+    AirflowException,
+    AirflowNotFoundException,
+    AirflowSkipException,
+)
 from airflow.providers.standard.operators.empty import EmptyOperator
+from airflow.sdk.execution_time.context import context_to_airflow_vars
 
+try:
+    from airflow.sdk import task, task_group
+except ImportError:
+    from airflow.decorators import task, task_group  # type: ignore[attr-defined,no-redef]
 try:
     from airflow.sdk import BaseHook
 except ImportError:
     from airflow.hooks.base import BaseHook  # type: ignore[attr-defined,no-redef]
-from airflow.sdk import Param
-
+try:
+    from airflow.sdk import Param
+except ImportError:
+    from airflow.models import Param  # type: ignore[attr-defined,no-redef]
 try:
     from airflow.sdk import TriggerRule
 except ImportError:
-    # Compatibility for Airflow < 3.1
     from airflow.utils.trigger_rule import TriggerRule  # type: ignore[no-redef,attr-defined]
-from airflow.sdk.execution_time.context import context_to_airflow_vars
-from airflow.utils.types import ArgNotSet
-
-if TYPE_CHECKING:
-    try:
-        from airflow.sdk.types import RuntimeTaskInstanceProtocol as TaskInstance
-    except ImportError:
-        from airflow.models import TaskInstance  # type: ignore[assignment]
-    from airflow.utils.context import Context
-
 try:
-    from airflow.operators.python import PythonOperator
+    from airflow.providers.common.compat.standard.operators import PythonOperator
+except ImportError:
+    from airflow.operators.python import PythonOperator  # type: ignore[no-redef]
+try:
+    from airflow.sdk.definitions._internal.types import NOTSET, ArgNotSet
 except ImportError:
-    from airflow.providers.common.compat.standard.operators import PythonOperator  # type: ignore[no-redef]
+    from airflow.utils.types import NOTSET, ArgNotSet  # type: ignore[attr-defined,no-redef]
+try:
+    from airflow.sdk.definitions._internal.types import is_arg_set
+except ImportError:
+
+    def is_arg_set(value):  # type: ignore[misc,no-redef]
+        return value is not NOTSET
+
+
+if TYPE_CHECKING:
+    from airflow.sdk import Context
+    from airflow.sdk.types import RuntimeTaskInstanceProtocol as TaskInstance
 
 
 class CmdOperator(BaseOperator):
@@ -163,7 +173,7 @@ class CmdOperator(BaseOperator):
         # When using the @task.command decorator, the command is not known until the underlying Python
         # callable is executed and therefore set to NOTSET initially. This flag is useful during execution to
         # determine whether the command value needs to re-rendered.
-        self._init_command_not_set = isinstance(self.command, ArgNotSet)
+        self._init_command_not_set = not is_arg_set(self.command)
 
     @staticmethod
     def refresh_command(ti: TaskInstance) -> None:

airflow/providers/edge3/executors/edge_executor.py

@@ -29,15 +29,14 @@ from sqlalchemy.orm import Session
 
 from airflow.cli.cli_config import GroupCommand
 from airflow.configuration import conf
+from airflow.executors import workloads
 from airflow.executors.base_executor import BaseExecutor
 from airflow.models.taskinstance import TaskInstance
-from airflow.providers.common.compat.sdk import timezone
+from airflow.providers.common.compat.sdk import Stats, timezone
 from airflow.providers.edge3.cli.edge_command import EDGE_COMMANDS
 from airflow.providers.edge3.models.edge_job import EdgeJobModel
 from airflow.providers.edge3.models.edge_logs import EdgeLogsModel
 from airflow.providers.edge3.models.edge_worker import EdgeWorkerModel, EdgeWorkerState, reset_metrics
-from airflow.providers.edge3.version_compat import AIRFLOW_V_3_0_PLUS
-from airflow.stats import Stats
 from airflow.utils.db import DBLocks, create_global_lock
 from airflow.utils.session import NEW_SESSION, provide_session
 from airflow.utils.state import TaskInstanceState
@@ -69,8 +68,10 @@ class EdgeExecutor(BaseExecutor):
         """
         Check if already existing table matches the newest table schema.
 
-        workaround till support for Airflow 2.x is dropped,
+        workaround as Airflow 2.x had no support for provider DB migrations,
         then it is possible to use alembic also for provider distributions.
+
+        TODO(jscheffl): Change to alembic DB migrations in the future.
         """
         inspector = inspect(engine)
         edge_job_columns = None
@@ -125,66 +126,13 @@ class EdgeExecutor(BaseExecutor):
         self.edge_queued_tasks = deepcopy(self.queued_tasks)
         super()._process_tasks(task_tuples)  # type: ignore[misc]
 
-    @provide_session
-    def execute_async(
-        self,
-        key: TaskInstanceKey,
-        command: CommandType,
-        queue: str | None = None,
-        executor_config: Any | None = None,
-        session: Session = NEW_SESSION,
-    ) -> None:
-        """Execute asynchronously. Airflow 2.10 entry point to execute a task."""
-        # Use of a temporary trick to get task instance, will be changed with Airflow 3.0.0
-        # code works together with _process_tasks overwrite to get task instance.
-        # TaskInstance in fourth element
-        task_instance = self.edge_queued_tasks[key][3]  # type: ignore[index]
-        del self.edge_queued_tasks[key]
-
-        self.validate_airflow_tasks_run_command(command)  # type: ignore[attr-defined]
-
-        # Check if job already exists with same dag_id, task_id, run_id, map_index, try_number
-        existing_job = (
-            session.query(EdgeJobModel)
-            .filter_by(
-                dag_id=key.dag_id,
-                task_id=key.task_id,
-                run_id=key.run_id,
-                map_index=key.map_index,
-                try_number=key.try_number,
-            )
-            .first()
-        )
-
-        if existing_job:
-            existing_job.state = TaskInstanceState.QUEUED
-            existing_job.queue = queue or DEFAULT_QUEUE
-            existing_job.concurrency_slots = task_instance.pool_slots
-            existing_job.command = str(command)
-        else:
-            session.add(
-                EdgeJobModel(
-                    dag_id=key.dag_id,
-                    task_id=key.task_id,
-                    run_id=key.run_id,
-                    map_index=key.map_index,
-                    try_number=key.try_number,
-                    state=TaskInstanceState.QUEUED,
-                    queue=queue or DEFAULT_QUEUE,
-                    concurrency_slots=task_instance.pool_slots,
-                    command=str(command),
-                )
-            )
-
     @provide_session
     def queue_workload(
         self,
-        workload: Any,  # Note actually "airflow.executors.workloads.All" but not existing in Airflow 2.10
+        workload: workloads.All,
         session: Session = NEW_SESSION,
     ) -> None:
         """Put new workload to queue. Airflow 3 entry point to execute a task."""
-        from airflow.executors import workloads
-
         if not isinstance(workload, workloads.ExecuteTask):
             raise TypeError(f"Don't know how to queue workload of type {type(workload).__name__}")
 
@@ -263,11 +211,7 @@ class EdgeExecutor(BaseExecutor):
 
     def _update_orphaned_jobs(self, session: Session) -> bool:
         """Update status ob jobs when workers die and don't update anymore."""
-        if AIRFLOW_V_3_0_PLUS:
-            heartbeat_interval_config_name = "task_instance_heartbeat_timeout"
-        else:
-            heartbeat_interval_config_name = "scheduler_zombie_task_threshold"
-        heartbeat_interval: int = conf.getint("scheduler", heartbeat_interval_config_name)
+        heartbeat_interval: int = conf.getint("scheduler", "task_instance_heartbeat_timeout")
         lifeless_jobs: list[EdgeJobModel] = (
             session.query(EdgeJobModel)
             .with_for_update(skip_locked=True)

airflow/providers/edge3/models/edge_worker.py

@@ -26,11 +26,9 @@ from typing import TYPE_CHECKING
 from sqlalchemy import Integer, String, delete, select
 from sqlalchemy.orm import Mapped
 
-from airflow.exceptions import AirflowException
 from airflow.models.base import Base
-from airflow.providers.common.compat.sdk import timezone
+from airflow.providers.common.compat.sdk import AirflowException, Stats, timezone
 from airflow.providers.common.compat.sqlalchemy.orm import mapped_column
-from airflow.stats import Stats
 from airflow.utils.log.logging_mixin import LoggingMixin
 from airflow.utils.providers_configuration_loader import providers_configuration_loaded
 from airflow.utils.session import NEW_SESSION, provide_session
@@ -50,6 +48,12 @@ class EdgeWorkerVersionException(AirflowException):
     pass
 
 
+class EdgeWorkerDuplicateException(AirflowException):
+    """Signal that a worker with the same name is already active."""
+
+    pass
+
+
 class EdgeWorkerState(str, Enum):
     """Status of a Edge Worker instance."""
 

airflow/providers/edge3/plugins/edge_executor_plugin.py

@@ -23,188 +23,35 @@ from typing import TYPE_CHECKING, Any
 from airflow.configuration import conf
 from airflow.exceptions import AirflowConfigException
 from airflow.plugins_manager import AirflowPlugin
-from airflow.providers.edge3.version_compat import AIRFLOW_V_3_0_PLUS, AIRFLOW_V_3_1_PLUS
+from airflow.providers.edge3.version_compat import AIRFLOW_V_3_1_PLUS
 from airflow.utils.session import NEW_SESSION, provide_session
 
 if TYPE_CHECKING:
     from sqlalchemy.orm import Session
 
-if AIRFLOW_V_3_0_PLUS:
-    from airflow.utils.db import DBLocks, create_global_lock
+from airflow.utils.db import DBLocks, create_global_lock
 
-    @provide_session
-    def _get_api_endpoint(session: Session = NEW_SESSION) -> dict[str, Any]:
-        # Ensure all required DB modeals are created before starting the API
-        with create_global_lock(session=session, lock=DBLocks.MIGRATIONS):
-            engine = session.get_bind().engine
-            from airflow.providers.edge3.models.edge_job import EdgeJobModel
-            from airflow.providers.edge3.models.edge_logs import EdgeLogsModel
-            from airflow.providers.edge3.models.edge_worker import EdgeWorkerModel
 
-            EdgeJobModel.metadata.create_all(engine)
-            EdgeLogsModel.metadata.create_all(engine)
-            EdgeWorkerModel.metadata.create_all(engine)
+@provide_session
+def _get_api_endpoint(session: Session = NEW_SESSION) -> dict[str, Any]:
+    # Ensure all required DB modeals are created before starting the API
+    with create_global_lock(session=session, lock=DBLocks.MIGRATIONS):
+        engine = session.get_bind().engine
+        from airflow.providers.edge3.models.edge_job import EdgeJobModel
+        from airflow.providers.edge3.models.edge_logs import EdgeLogsModel
+        from airflow.providers.edge3.models.edge_worker import EdgeWorkerModel
 
-        from airflow.providers.edge3.worker_api.app import create_edge_worker_api_app
+        EdgeJobModel.metadata.create_all(engine)
+        EdgeLogsModel.metadata.create_all(engine)
+        EdgeWorkerModel.metadata.create_all(engine)
 
-        return {
-            "app": create_edge_worker_api_app(),
-            "url_prefix": "/edge_worker",
-            "name": "Airflow Edge Worker",
-        }
+    from airflow.providers.edge3.worker_api.app import create_edge_worker_api_app
 
-else:
-    # This is for back-compatibility with Airflow 2.x and we only make this
-    # to prevents dependencies and breaking imports in Airflow 3.x
-    import re
-    from datetime import datetime, timedelta
-    from pathlib import Path
-
-    from flask import Blueprint, redirect, request, url_for
-    from flask_appbuilder import BaseView, expose
-    from markupsafe import Markup
-    from sqlalchemy import select
-
-    from airflow.auth.managers.models.resource_details import AccessView
-    from airflow.utils.state import State, TaskInstanceState
-    from airflow.utils.yaml import safe_load
-    from airflow.www.auth import has_access_view
-
-    def _get_airflow_2_api_endpoint() -> Blueprint:
-        from airflow.www.app import csrf
-        from airflow.www.constants import SWAGGER_BUNDLE, SWAGGER_ENABLED
-        from airflow.www.extensions.init_views import _CustomErrorRequestBodyValidator, _LazyResolver
-
-        folder = Path(__file__).parents[1].resolve()  # this is airflow/providers/edge3/
-        with folder.joinpath("openapi", "edge_worker_api_v1.yaml").open() as f:
-            specification = safe_load(f)
-        from connexion import FlaskApi
-
-        bp = FlaskApi(
-            specification=specification,
-            resolver=_LazyResolver(),
-            base_path="/edge_worker/v1",
-            strict_validation=True,
-            options={"swagger_ui": SWAGGER_ENABLED, "swagger_path": SWAGGER_BUNDLE.__fspath__()},
-            validate_responses=True,
-            validator_map={"body": _CustomErrorRequestBodyValidator},
-        ).blueprint
-        # Need to exempt CSRF to make API usable
-        csrf.exempt(bp)
-        return bp
-
-    def _state_token(state):
-        """Return a formatted string with HTML for a given State."""
-        color = State.color(state)
-        fg_color = State.color_fg(state)
-        return Markup(
-            """
-            <span class="label" style="color:{fg_color}; background-color:{color};"
-                title="Current State: {state}">{state}</span>
-            """
-        ).format(color=color, state=state, fg_color=fg_color)
-
-    def modify_maintenance_comment_on_update(maintenance_comment: str | None, username: str) -> str:
-        if maintenance_comment:
-            if re.search(
-                r"^\[[-\d:\s]+\] - .+ put node into maintenance mode\r?\nComment:.*", maintenance_comment
-            ):
-                return re.sub(
-                    r"^\[[-\d:\s]+\] - .+ put node into maintenance mode\r?\nComment:",
-                    f"[{datetime.now().strftime('%Y-%m-%d %H:%M')}] - {username} updated maintenance mode\nComment:",
-                    maintenance_comment,
-                )
-            if re.search(r"^\[[-\d:\s]+\] - .+ updated maintenance mode\r?\nComment:.*", maintenance_comment):
-                return re.sub(
-                    r"^\[[-\d:\s]+\] - .+ updated maintenance mode\r?\nComment:",
-                    f"[{datetime.now().strftime('%Y-%m-%d %H:%M')}] - {username} updated maintenance mode\nComment:",
-                    maintenance_comment,
-                )
-            return f"[{datetime.now().strftime('%Y-%m-%d %H:%M')}] - {username} updated maintenance mode\nComment: {maintenance_comment}"
-        return (
-            f"[{datetime.now().strftime('%Y-%m-%d %H:%M')}] - {username} updated maintenance mode\nComment:"
-        )
-
-    # registers airflow/providers/edge3/plugins/templates as a Jinja template folder
-    template_bp = Blueprint(
-        "template_blueprint",
-        __name__,
-        template_folder="templates",
-    )
-
-    class EdgeWorkerJobs(BaseView):
-        """Simple view to show Edge Worker jobs."""
-
-        default_view = "jobs"
-
-        @expose("/jobs")
-        @has_access_view(AccessView.JOBS)
-        @provide_session
-        def jobs(self, session: Session = NEW_SESSION):
-            from airflow.providers.edge3.models.edge_job import EdgeJobModel
-
-            jobs = session.scalars(select(EdgeJobModel).order_by(EdgeJobModel.queued_dttm)).all()
-            html_states = {
-                str(state): _state_token(str(state)) for state in TaskInstanceState.__members__.values()
-            }
-            return self.render_template("edge_worker_jobs.html", jobs=jobs, html_states=html_states)
-
-    class EdgeWorkerHosts(BaseView):
-        """Simple view to show Edge Worker status."""
-
-        default_view = "status"
-
-        @expose("/status")
-        @has_access_view(AccessView.JOBS)
-        @provide_session
-        def status(self, session: Session = NEW_SESSION):
-            from airflow.providers.edge3.models.edge_worker import EdgeWorkerModel
-
-            hosts = session.scalars(select(EdgeWorkerModel).order_by(EdgeWorkerModel.worker_name)).all()
-            five_min_ago = datetime.now() - timedelta(minutes=5)
-            return self.render_template("edge_worker_hosts.html", hosts=hosts, five_min_ago=five_min_ago)
-
-        @expose("/status/maintenance/<string:worker_name>/on", methods=["POST"])
-        @has_access_view(AccessView.JOBS)
-        def worker_to_maintenance(self, worker_name: str):
-            from flask_login import current_user
-
-            from airflow.providers.edge3.models.edge_worker import request_maintenance
-
-            maintenance_comment = request.form.get("maintenance_comment")
-            maintenance_comment = f"[{datetime.now().strftime('%Y-%m-%d %H:%M')}] - {current_user.username} put node into maintenance mode\nComment: {maintenance_comment}"
-            request_maintenance(worker_name, maintenance_comment)
-            return redirect(url_for("EdgeWorkerHosts.status"))
-
-        @expose("/status/maintenance/<string:worker_name>/off", methods=["POST"])
-        @has_access_view(AccessView.JOBS)
-        def remove_worker_from_maintenance(self, worker_name: str):
-            from airflow.providers.edge3.models.edge_worker import exit_maintenance
-
-            exit_maintenance(worker_name)
-            return redirect(url_for("EdgeWorkerHosts.status"))
-
-        @expose("/status/maintenance/<string:worker_name>/remove", methods=["POST"])
-        @has_access_view(AccessView.JOBS)
-        def remove_worker(self, worker_name: str):
-            from airflow.providers.edge3.models.edge_worker import remove_worker
-
-            remove_worker(worker_name)
-            return redirect(url_for("EdgeWorkerHosts.status"))
-
-        @expose("/status/maintenance/<string:worker_name>/change_comment", methods=["POST"])
-        @has_access_view(AccessView.JOBS)
-        def change_maintenance_comment(self, worker_name: str):
-            from flask_login import current_user
-
-            from airflow.providers.edge3.models.edge_worker import change_maintenance_comment
-
-            maintenance_comment = request.form.get("maintenance_comment")
-            maintenance_comment = modify_maintenance_comment_on_update(
-                maintenance_comment, current_user.username
-            )
-            change_maintenance_comment(worker_name, maintenance_comment)
-            return redirect(url_for("EdgeWorkerHosts.status"))
+    return {
+        "app": create_edge_worker_api_app(),
+        "url_prefix": "/edge_worker",
+        "name": "Airflow Edge Worker",
+    }
 
 
 # Check if EdgeExecutor is actually loaded
@@ -213,17 +60,14 @@ try:
 except AirflowConfigException:
     EDGE_EXECUTOR_ACTIVE = False
 
-# Load the API endpoint only on api-server (Airflow 3.x) or webserver (Airflow 2.x)
-# todo(jscheffl): Remove this check when the discussion in
+# Load the API endpoint only on api-server
+# TODO(jscheffl): Remove this check when the discussion in
 #                 https://lists.apache.org/thread/w170czq6r7bslkqp1tk6bjjjo0789wgl
 #                 resulted in a proper API to selective initialize. Maybe backcompat-shim
 #                 is also needed to support Airflow-versions prior the rework.
-if AIRFLOW_V_3_0_PLUS:
-    RUNNING_ON_APISERVER = (len(sys.argv) > 1 and sys.argv[1] in ["api-server"]) or (
-        len(sys.argv) > 2 and sys.argv[2] == "airflow-core/src/airflow/api_fastapi/main.py"
-    )
-else:
-    RUNNING_ON_APISERVER = "gunicorn" in sys.argv[0] and "airflow-webserver" in sys.argv
+RUNNING_ON_APISERVER = (len(sys.argv) > 1 and sys.argv[1] in ["api-server"]) or (
+    len(sys.argv) > 2 and sys.argv[2] == "airflow-core/src/airflow/api_fastapi/main.py"
+)
 
 
 def _get_base_url_path(path: str) -> str:
@@ -247,8 +91,9 @@ class EdgeExecutorPlugin(AirflowPlugin):
 
     name = "edge_executor"
     if EDGE_EXECUTOR_ACTIVE and RUNNING_ON_APISERVER:
+        fastapi_apps = [_get_api_endpoint()]
         if AIRFLOW_V_3_1_PLUS:
-            fastapi_apps = [_get_api_endpoint()]
+            # Airflow 3.0 does not know about react_apps, so we only provide the API endpoint
             react_apps = [
                 {
                     "name": "Edge Executor",
@@ -271,27 +116,3 @@ class EdgeExecutorPlugin(AirflowPlugin):
                     "url_route": "edge_worker_api_docs",
                 }
             ]
-        if AIRFLOW_V_3_0_PLUS:
-            # Airflow 3.0 does not know about react_apps, so we only provide the API endpoint
-            fastapi_apps = [_get_api_endpoint()]
-        else:
-            appbuilder_menu_items = [
-                {
-                    "name": "Edge Worker API docs",
-                    "href": _get_base_url_path("/edge_worker/v1/ui"),
-                    "category": "Docs",
-                }
-            ]
-            appbuilder_views = [
-                {
-                    "name": "Edge Worker Jobs",
-                    "category": "Admin",
-                    "view": EdgeWorkerJobs(),
-                },
-                {
-                    "name": "Edge Worker Hosts",
-                    "category": "Admin",
-                    "view": EdgeWorkerHosts(),
-                },
-            ]
-            flask_blueprints = [_get_airflow_2_api_endpoint(), template_bp]