apache-airflow-providers-edge3 1.1.0rc1__py3-none-any.whl → 1.1.1rc1__py3-none-any.whl

airflow/providers/edge3/__init__.py

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

airflow/providers/edge3/cli/edge_command.py

@@ -24,45 +24,31 @@ import sys
 from dataclasses import asdict
 from datetime import datetime
 from getpass import getuser
-from http import HTTPStatus
-from multiprocessing import Process
 from pathlib import Path
-from subprocess import Popen
 from time import sleep, time
-from typing import TYPE_CHECKING
 
 import psutil
-from lockfile.pidlockfile import read_pid_from_pidfile, remove_existing_pidfile, write_pid_to_pidfile
-from requests import HTTPError
 
-from airflow import __version__ as airflow_version, settings
+from airflow import settings
 from airflow.cli.cli_config import ARG_PID, ARG_VERBOSE, ActionCommand, Arg
 from airflow.cli.commands.daemon_utils import run_command_with_daemon_option
 from airflow.cli.simple_table import AirflowConsole
 from airflow.configuration import conf
-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,
+from airflow.providers.edge3.cli.dataclasses import MaintenanceMarker, WorkerStatus
+from airflow.providers.edge3.cli.signalling import (
+    EDGE_WORKER_PROCESS_NAME,
+    get_pid,
+    maintenance_marker_file_path,
+    pid_file_path,
+    status_file_path,
 )
-from airflow.providers.edge3.cli.dataclasses import Job, MaintenanceMarker, WorkerStatus
-from airflow.providers.edge3.models.edge_worker import EdgeWorkerState, EdgeWorkerVersionException
-from airflow.providers.edge3.version_compat import AIRFLOW_V_3_0_PLUS
-from airflow.utils import cli as cli_utils, timezone
+from airflow.providers.edge3.cli.worker import SIG_STATUS, EdgeWorker
+from airflow.providers.edge3.models.edge_worker import EdgeWorkerState
+from airflow.utils import cli as cli_utils
 from airflow.utils.net import getfqdn
-from airflow.utils.platform import IS_WINDOWS
 from airflow.utils.providers_configuration_loader import providers_configuration_loaded
-from airflow.utils.state import TaskInstanceState
-
-if TYPE_CHECKING:
-    from airflow.providers.edge3.worker_api.datamodels import EdgeJobFetched
 
 logger = logging.getLogger(__name__)
-EDGE_WORKER_PROCESS_NAME = "edge-worker"
 EDGE_WORKER_HEADER = "\n".join(
     [
         r"   ____   __           _      __         __",
@@ -98,411 +84,13 @@ def force_use_internal_api_on_edge_worker():
 force_use_internal_api_on_edge_worker()
 
 
-def _status_signal() -> signal.Signals:
-    if IS_WINDOWS:
-        return signal.SIGBREAK  # type: ignore[attr-defined]
-    return signal.SIGUSR2
-
-
-SIG_STATUS = _status_signal()
-
-
-def _pid_file_path(pid_file: str | None) -> str:
-    return cli_utils.setup_locations(process=EDGE_WORKER_PROCESS_NAME, pid=pid_file)[0]
-
-
-def _get_pid(pid_file: str | None) -> int:
-    pid = read_pid_from_pidfile(_pid_file_path(pid_file))
-    if not pid:
-        logger.warning("Could not find PID of worker.")
-        sys.exit(1)
-    return pid
-
-
-def _status_file_path(pid_file: str | None) -> str:
-    return cli_utils.setup_locations(process=EDGE_WORKER_PROCESS_NAME, pid=pid_file)[1]
-
-
-def _maintenance_marker_file_path(pid_file: str | None) -> str:
-    return cli_utils.setup_locations(process=EDGE_WORKER_PROCESS_NAME, pid=pid_file)[1][:-4] + ".in"
-
-
-def _write_pid_to_pidfile(pid_file_path: str):
-    """Write PIDs for Edge Workers to disk, handling existing PID files."""
-    if Path(pid_file_path).exists():
-        # Handle existing PID files on disk
-        logger.info("An existing PID file has been found: %s.", pid_file_path)
-        pid_stored_in_pid_file = read_pid_from_pidfile(pid_file_path)
-        if os.getpid() == pid_stored_in_pid_file:
-            raise SystemExit("A PID file has already been written")
-        # PID file was written by dead or already running instance
-        if psutil.pid_exists(pid_stored_in_pid_file):
-            # case 1: another instance uses the same path for its PID file
-            raise SystemExit(
-                f"The PID file {pid_file_path} contains the PID of another running process. "
-                "Configuration issue: edge worker instance must use different PID file paths!"
-            )
-        # case 2: previous instance crashed without cleaning up its PID file
-        logger.warning("PID file is orphaned. Cleaning up.")
-        remove_existing_pidfile(pid_file_path)
-    logger.debug("PID file written to %s.", pid_file_path)
-    write_pid_to_pidfile(pid_file_path)
-
-
-def _edge_hostname() -> str:
-    """Get the hostname of the edge worker that should be reported by tasks."""
-    return os.environ.get("HOSTNAME", getfqdn())
-
-
-class _EdgeWorkerCli:
-    """Runner instance which executes the Edge Worker."""
-
-    jobs: list[Job] = []
-    """List of jobs that the worker is running currently."""
-    last_hb: datetime | None = None
-    """Timestamp of last heart beat sent to server."""
-    drain: bool = False
-    """Flag if job processing should be completed and no new jobs fetched for a graceful stop/shutdown."""
-    maintenance_mode: bool = False
-    """Flag if job processing should be completed and no new jobs fetched for maintenance mode. """
-    maintenance_comments: str | None = None
-    """Comments for maintenance mode."""
-    edge_instance: _EdgeWorkerCli | None = None
-    """Singleton instance of the worker."""
-
-    def __init__(
-        self,
-        pid_file_path: str,
-        hostname: str,
-        queues: list[str] | None,
-        concurrency: int,
-        job_poll_interval: int,
-        heartbeat_interval: int,
-        daemon: bool = False,
-    ):
-        self.pid_file_path = pid_file_path
-        self.job_poll_interval = job_poll_interval
-        self.hb_interval = heartbeat_interval
-        self.hostname = hostname
-        self.queues = queues
-        self.concurrency = concurrency
-        self.free_concurrency = concurrency
-        self.daemon = daemon
-
-        _EdgeWorkerCli.edge_instance = self
-
-    @staticmethod
-    def signal_handler(sig: signal.Signals, frame):
-        if sig == SIG_STATUS:
-            marker_path = Path(_maintenance_marker_file_path(None))
-            if marker_path.exists():
-                request = MaintenanceMarker.from_json(marker_path.read_text())
-                logger.info("Requested to set maintenance mode to %s", request.maintenance)
-                _EdgeWorkerCli.maintenance_mode = request.maintenance == "on"
-                if _EdgeWorkerCli.maintenance_mode and request.comments:
-                    logger.info("Comments: %s", request.comments)
-                    _EdgeWorkerCli.maintenance_comments = request.comments
-                marker_path.unlink()
-                # send heartbeat immediately to update state
-                if _EdgeWorkerCli.edge_instance:
-                    _EdgeWorkerCli.edge_instance.heartbeat(_EdgeWorkerCli.maintenance_comments)
-            else:
-                logger.info("Request to get status of Edge Worker received.")
-            status_path = Path(_status_file_path(None))
-            status_path.write_text(
-                WorkerStatus(
-                    job_count=len(_EdgeWorkerCli.jobs),
-                    jobs=[job.edge_job.key for job in _EdgeWorkerCli.jobs],
-                    state=_EdgeWorkerCli._get_state(),
-                    maintenance=_EdgeWorkerCli.maintenance_mode,
-                    maintenance_comments=_EdgeWorkerCli.maintenance_comments,
-                    drain=_EdgeWorkerCli.drain,
-                ).json
-            )
-        else:
-            logger.info("Request to shut down Edge Worker received, waiting for jobs to complete.")
-            _EdgeWorkerCli.drain = True
-
-    def shutdown_handler(self, sig, frame):
-        logger.info("SIGTERM received. Terminating all jobs and quit")
-        for job in _EdgeWorkerCli.jobs:
-            os.killpg(job.process.pid, signal.SIGTERM)
-        _EdgeWorkerCli.drain = True
-
-    def _get_sysinfo(self) -> dict:
-        """Produce the sysinfo from worker to post to central site."""
-        return {
-            "airflow_version": airflow_version,
-            "edge_provider_version": edge_provider_version,
-            "concurrency": self.concurrency,
-            "free_concurrency": self.free_concurrency,
-        }
-
-    @staticmethod
-    def _get_state() -> EdgeWorkerState:
-        """State of the Edge Worker."""
-        if _EdgeWorkerCli.jobs:
-            if _EdgeWorkerCli.drain:
-                return EdgeWorkerState.TERMINATING
-            if _EdgeWorkerCli.maintenance_mode:
-                return EdgeWorkerState.MAINTENANCE_PENDING
-            return EdgeWorkerState.RUNNING
-
-        if _EdgeWorkerCli.drain:
-            if _EdgeWorkerCli.maintenance_mode:
-                return EdgeWorkerState.OFFLINE_MAINTENANCE
-            return EdgeWorkerState.OFFLINE
-
-        if _EdgeWorkerCli.maintenance_mode:
-            return EdgeWorkerState.MAINTENANCE_MODE
-        return EdgeWorkerState.IDLE
-
-    def _launch_job_af3(self, edge_job: EdgeJobFetched) -> tuple[Process, Path]:
-        if TYPE_CHECKING:
-            from airflow.executors.workloads import ExecuteTask
-
-        def _run_job_via_supervisor(
-            workload: ExecuteTask,
-        ) -> int:
-            from setproctitle import setproctitle
-
-            from airflow.sdk.execution_time.supervisor import supervise
-
-            # Ignore ctrl-c in this process -- we don't want to kill _this_ one. we let tasks run to completion
-            signal.signal(signal.SIGINT, signal.SIG_IGN)
-
-            logger.info("Worker starting up pid=%d", os.getpid())
-            setproctitle(f"airflow edge worker: {workload.ti.key}")
-
-            try:
-                base_url = conf.get("api", "base_url", fallback="/")
-                # If it's a relative URL, use localhost:8080 as the default
-                if base_url.startswith("/"):
-                    base_url = f"http://localhost:8080{base_url}"
-                default_execution_api_server = f"{base_url.rstrip('/')}/execution/"
-
-                supervise(
-                    # This is the "wrong" ti type, but it duck types the same. TODO: Create a protocol for this.
-                    # Same like in airflow/executors/local_executor.py:_execute_work()
-                    ti=workload.ti,  # type: ignore[arg-type]
-                    dag_rel_path=workload.dag_rel_path,
-                    bundle_info=workload.bundle_info,
-                    token=workload.token,
-                    server=conf.get(
-                        "core", "execution_api_server_url", fallback=default_execution_api_server
-                    ),
-                    log_path=workload.log_path,
-                )
-                return 0
-            except Exception as e:
-                logger.exception("Task execution failed: %s", e)
-                return 1
-
-        workload: ExecuteTask = edge_job.command
-        process = Process(
-            target=_run_job_via_supervisor,
-            kwargs={"workload": workload},
-        )
-        process.start()
-        base_log_folder = conf.get("logging", "base_log_folder", fallback="NOT AVAILABLE")
-        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
-
-    def _launch_job_af2_10(self, 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
-
-    def _launch_job(self, edge_job: EdgeJobFetched):
-        """Get the received job executed."""
-        process: Popen | Process
-        if AIRFLOW_V_3_0_PLUS:
-            process, logfile = self._launch_job_af3(edge_job)
-        else:
-            # Airflow 2.10
-            process, logfile = self._launch_job_af2_10(edge_job)
-        _EdgeWorkerCli.jobs.append(Job(edge_job, process, logfile, 0))
-
-    def start(self):
-        """Start the execution in a loop until terminated."""
-        try:
-            self.last_hb = worker_register(
-                self.hostname, EdgeWorkerState.STARTING, self.queues, self._get_sysinfo()
-            ).last_update
-        except EdgeWorkerVersionException as e:
-            logger.info("Version mismatch of Edge worker and Core. Shutting down worker.")
-            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.")
-            raise SystemExit(str(e))
-        if not self.daemon:
-            _write_pid_to_pidfile(self.pid_file_path)
-        signal.signal(signal.SIGINT, _EdgeWorkerCli.signal_handler)
-        signal.signal(SIG_STATUS, _EdgeWorkerCli.signal_handler)
-        signal.signal(signal.SIGTERM, self.shutdown_handler)
-        os.environ["HOSTNAME"] = self.hostname
-        os.environ["AIRFLOW__CORE__HOSTNAME_CALLABLE"] = f"{_edge_hostname.__module__}._edge_hostname"
-        try:
-            self.worker_state_changed = self.heartbeat()
-            self.last_hb = datetime.now()
-            while not _EdgeWorkerCli.drain or _EdgeWorkerCli.jobs:
-                self.loop()
-
-            logger.info("Quitting worker, signal being offline.")
-            try:
-                worker_set_state(
-                    self.hostname,
-                    EdgeWorkerState.OFFLINE_MAINTENANCE
-                    if _EdgeWorkerCli.maintenance_mode
-                    else EdgeWorkerState.OFFLINE,
-                    0,
-                    self.queues,
-                    self._get_sysinfo(),
-                )
-            except EdgeWorkerVersionException:
-                logger.info("Version mismatch of Edge worker and Core. Quitting worker anyway.")
-        finally:
-            if not self.daemon:
-                remove_existing_pidfile(self.pid_file_path)
-
-    def loop(self):
-        """Run a loop of scheduling and monitoring tasks."""
-        new_job = False
-        previous_jobs = _EdgeWorkerCli.jobs
-        if not any((_EdgeWorkerCli.drain, _EdgeWorkerCli.maintenance_mode)) and self.free_concurrency > 0:
-            new_job = self.fetch_job()
-        self.check_running_jobs()
-
-        if (
-            _EdgeWorkerCli.drain
-            or datetime.now().timestamp() - self.last_hb.timestamp() > self.hb_interval
-            or self.worker_state_changed  # send heartbeat immediately if the state is different in db
-            or bool(previous_jobs) != bool(_EdgeWorkerCli.jobs)  # when number of jobs changes from/to 0
-        ):
-            self.worker_state_changed = self.heartbeat()
-            self.last_hb = datetime.now()
-
-        if not new_job:
-            self.interruptible_sleep()
-
-    def fetch_job(self) -> bool:
-        """Fetch and start a new job from central site."""
-        logger.debug("Attempting to fetch a new job...")
-        edge_job = jobs_fetch(self.hostname, self.queues, self.free_concurrency)
-        if edge_job:
-            logger.info("Received job: %s", edge_job)
-            self._launch_job(edge_job)
-            jobs_set_state(edge_job.key, TaskInstanceState.RUNNING)
-            return True
-
-        logger.info(
-            "No new job to process%s",
-            f", {len(_EdgeWorkerCli.jobs)} still running" if _EdgeWorkerCli.jobs else "",
-        )
-        return False
-
-    def check_running_jobs(self) -> None:
-        """Check which of the running tasks/jobs are completed and report back."""
-        used_concurrency = 0
-        for i in range(len(_EdgeWorkerCli.jobs) - 1, -1, -1):
-            job = _EdgeWorkerCli.jobs[i]
-            if not job.is_running:
-                _EdgeWorkerCli.jobs.remove(job)
-                if job.is_success:
-                    logger.info("Job completed: %s", job.edge_job)
-                    jobs_set_state(job.edge_job.key, TaskInstanceState.SUCCESS)
-                else:
-                    logger.error("Job failed: %s", job.edge_job)
-                    jobs_set_state(job.edge_job.key, TaskInstanceState.FAILED)
-            else:
-                used_concurrency += job.edge_job.concurrency_slots
-
-            if job.logfile.exists() and job.logfile.stat().st_size > job.logsize:
-                with job.logfile.open("rb") as logfile:
-                    push_log_chunk_size = conf.getint("edge", "push_log_chunk_size")
-                    logfile.seek(job.logsize, os.SEEK_SET)
-                    read_data = logfile.read()
-                    job.logsize += len(read_data)
-                    # backslashreplace to keep not decoded characters and not raising exception
-                    # replace null with question mark to fix issue during DB push
-                    log_data = read_data.decode(errors="backslashreplace").replace("\x00", "\ufffd")
-                    while True:
-                        chunk_data = log_data[:push_log_chunk_size]
-                        log_data = log_data[push_log_chunk_size:]
-                        if not chunk_data:
-                            break
-
-                        logs_push(
-                            task=job.edge_job.key,
-                            log_chunk_time=timezone.utcnow(),
-                            log_chunk_data=chunk_data,
-                        )
-
-        self.free_concurrency = self.concurrency - used_concurrency
-
-    def heartbeat(self, new_maintenance_comments: str | None = None) -> bool:
-        """Report liveness state of worker to central site with stats."""
-        state = _EdgeWorkerCli._get_state()
-        sysinfo = self._get_sysinfo()
-        worker_state_changed: bool = False
-        try:
-            worker_info = worker_set_state(
-                self.hostname,
-                state,
-                len(_EdgeWorkerCli.jobs),
-                self.queues,
-                sysinfo,
-                new_maintenance_comments,
-            )
-            self.queues = worker_info.queues
-            if worker_info.state == EdgeWorkerState.MAINTENANCE_REQUEST:
-                logger.info("Maintenance mode requested!")
-                _EdgeWorkerCli.maintenance_mode = True
-            elif (
-                worker_info.state in [EdgeWorkerState.IDLE, EdgeWorkerState.RUNNING]
-                and _EdgeWorkerCli.maintenance_mode
-            ):
-                logger.info("Exit Maintenance mode requested!")
-                _EdgeWorkerCli.maintenance_mode = False
-            if _EdgeWorkerCli.maintenance_mode:
-                _EdgeWorkerCli.maintenance_comments = worker_info.maintenance_comments
-            else:
-                _EdgeWorkerCli.maintenance_comments = None
-            if worker_info.state == EdgeWorkerState.SHUTDOWN_REQUEST:
-                logger.info("Shutdown requested!")
-                _EdgeWorkerCli.drain = True
-
-            worker_state_changed = worker_info.state != state
-        except EdgeWorkerVersionException:
-            logger.info("Version mismatch of Edge worker and Core. Shutting down worker.")
-            _EdgeWorkerCli.drain = True
-        return worker_state_changed
-
-    def interruptible_sleep(self):
-        """Sleeps but stops sleeping if drain is made."""
-        drain_before_sleep = _EdgeWorkerCli.drain
-        for _ in range(0, self.job_poll_interval * 10):
-            sleep(0.1)
-            if drain_before_sleep != _EdgeWorkerCli.drain:
-                return
-
-
 @providers_configuration_loaded
 def _launch_worker(args):
     print(settings.HEADER)
     print(EDGE_WORKER_HEADER)
 
-    edge_worker = _EdgeWorkerCli(
-        pid_file_path=_pid_file_path(args.pid),
+    edge_worker = EdgeWorker(
+        pid_file_path=pid_file_path(args.pid),
         hostname=args.edge_hostname or getfqdn(),
         queues=args.queues.split(",") if args.queues else None,
         concurrency=args.concurrency,
@@ -524,7 +112,7 @@ def worker(args):
         process_name=EDGE_WORKER_PROCESS_NAME,
         callback=lambda: _launch_worker(args),
         should_setup_logging=True,
-        pid_file=_pid_file_path(args.pid),
+        pid_file=pid_file_path(args.pid),
         umask=umask,
     )
 
@@ -533,12 +121,12 @@ def worker(args):
 @providers_configuration_loaded
 def status(args):
     """Check for Airflow Local Edge Worker status."""
-    pid = _get_pid(args.pid)
+    pid = get_pid(args.pid)
 
     # Send Signal as notification to drop status JSON
     logger.debug("Sending SIGUSR2 to worker pid %i.", pid)
     status_min_date = time() - 1
-    status_path = Path(_status_file_path(args.pid))
+    status_path = Path(status_file_path(args.pid))
     worker_process = psutil.Process(pid)
     worker_process.send_signal(SIG_STATUS)
     while psutil.pid_exists(pid) and (
@@ -563,12 +151,12 @@ def maintenance(args):
         logger.error("Comments are required when setting maintenance mode.")
         sys.exit(4)
 
-    pid = _get_pid(args.pid)
+    pid = get_pid(args.pid)
 
     # Write marker JSON file
     from getpass import getuser
 
-    marker_path = Path(_maintenance_marker_file_path(args.pid))
+    marker_path = Path(maintenance_marker_file_path(args.pid))
     logger.debug("Writing maintenance marker file to %s.", marker_path)
     marker_path.write_text(
         MaintenanceMarker(
@@ -583,7 +171,7 @@ def maintenance(args):
     # Send Signal as notification to fetch maintenance marker
     logger.debug("Sending SIGUSR2 to worker pid %i.", pid)
     status_min_date = time() - 1
-    status_path = Path(_status_file_path(args.pid))
+    status_path = Path(status_file_path(args.pid))
     worker_process = psutil.Process(pid)
     worker_process.send_signal(SIG_STATUS)
     while psutil.pid_exists(pid) and (
@@ -630,7 +218,7 @@ def maintenance(args):
 @providers_configuration_loaded
 def stop(args):
     """Stop a running local Airflow Edge Worker."""
-    pid = _get_pid(args.pid)
+    pid = get_pid(args.pid)
     # Send SIGINT
     logger.info("Sending SIGINT to worker pid %i.", pid)
     worker_process = psutil.Process(pid)
@@ -674,9 +262,26 @@ def list_edge_workers(args) -> None:
         "worker_name",
         "state",
         "queues",
+        "jobs_active",
+        "concurrency",
+        "free_concurrency",
         "maintenance_comment",
     ]
-    all_hosts = [{f: host.__getattribute__(f) for f in fields} for host in all_hosts_iter]
+
+    all_hosts = []
+    for host in all_hosts_iter:
+        host_data = {
+            f: getattr(host, f, None) for f in fields if f not in ("concurrency", "free_concurrency")
+        }
+        try:
+            sysinfo = json.loads(host.sysinfo or "{}")
+            host_data["concurrency"] = sysinfo.get("concurrency")
+            host_data["free_concurrency"] = sysinfo.get("free_concurrency")
+        except (json.JSONDecodeError, TypeError):
+            host_data["concurrency"] = None
+            host_data["free_concurrency"] = None
+        all_hosts.append(host_data)
+
     AirflowConsole().print_as(data=all_hosts, output=args.output)
 
 

airflow/providers/edge3/cli/signalling.py

@@ -0,0 +1,88 @@
+# 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
+
+import logging
+import os
+import signal
+import sys
+from pathlib import Path
+
+import psutil
+from lockfile.pidlockfile import (
+    read_pid_from_pidfile,
+    remove_existing_pidfile,
+    write_pid_to_pidfile as write_pid,
+)
+
+from airflow.utils import cli as cli_utils
+from airflow.utils.platform import IS_WINDOWS
+
+EDGE_WORKER_PROCESS_NAME = "edge-worker"
+
+logger = logging.getLogger(__name__)
+
+
+def _status_signal() -> signal.Signals:
+    if IS_WINDOWS:
+        return signal.SIGBREAK  # type: ignore[attr-defined]
+    return signal.SIGUSR2
+
+
+SIG_STATUS = _status_signal()
+
+
+def write_pid_to_pidfile(pid_file_path: str):
+    """Write PIDs for Edge Workers to disk, handling existing PID files."""
+    if Path(pid_file_path).exists():
+        # Handle existing PID files on disk
+        logger.info("An existing PID file has been found: %s.", pid_file_path)
+        pid_stored_in_pid_file = read_pid_from_pidfile(pid_file_path)
+        if os.getpid() == pid_stored_in_pid_file:
+            raise SystemExit("A PID file has already been written")
+        # PID file was written by dead or already running instance
+        if psutil.pid_exists(pid_stored_in_pid_file):
+            # case 1: another instance uses the same path for its PID file
+            raise SystemExit(
+                f"The PID file {pid_file_path} contains the PID of another running process. "
+                "Configuration issue: edge worker instance must use different PID file paths!"
+            )
+        # case 2: previous instance crashed without cleaning up its PID file
+        logger.warning("PID file is orphaned. Cleaning up.")
+        remove_existing_pidfile(pid_file_path)
+    logger.debug("PID file written to %s.", pid_file_path)
+    write_pid(pid_file_path)
+
+
+def pid_file_path(pid_file: str | None) -> str:
+    return cli_utils.setup_locations(process=EDGE_WORKER_PROCESS_NAME, pid=pid_file)[0]
+
+
+def get_pid(pid_file: str | None) -> int:
+    pid = read_pid_from_pidfile(pid_file_path(pid_file))
+    if not pid:
+        logger.warning("Could not find PID of worker.")
+        sys.exit(1)
+    return pid
+
+
+def status_file_path(pid_file: str | None) -> str:
+    return cli_utils.setup_locations(process=EDGE_WORKER_PROCESS_NAME, pid=pid_file)[1]
+
+
+def maintenance_marker_file_path(pid_file: str | None) -> str:
+    return cli_utils.setup_locations(process=EDGE_WORKER_PROCESS_NAME, pid=pid_file)[1][:-4] + ".in"

airflow/providers/edge3/cli/worker.py

@@ -0,0 +1,407 @@
+# 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
+
+import logging
+import os
+import signal
+from datetime import datetime
+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
+
+from lockfile.pidlockfile import remove_existing_pidfile
+from requests import HTTPError
+
+from airflow import __version__ as airflow_version
+from airflow.configuration import conf
+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,
+)
+from airflow.providers.edge3.cli.dataclasses import Job, MaintenanceMarker, WorkerStatus
+from airflow.providers.edge3.cli.signalling import (
+    SIG_STATUS,
+    maintenance_marker_file_path,
+    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.utils import timezone
+from airflow.utils.net import getfqdn
+from airflow.utils.state import TaskInstanceState
+
+if TYPE_CHECKING:
+    from airflow.providers.edge3.worker_api.datamodels import EdgeJobFetched
+
+logger = logging.getLogger(__name__)
+
+
+def _edge_hostname() -> str:
+    """Get the hostname of the edge worker that should be reported by tasks."""
+    return os.environ.get("HOSTNAME", getfqdn())
+
+
+class EdgeWorker:
+    """Runner instance which executes the Edge Worker."""
+
+    jobs: list[Job] = []
+    """List of jobs that the worker is running currently."""
+    last_hb: datetime | None = None
+    """Timestamp of last heart beat sent to server."""
+    drain: bool = False
+    """Flag if job processing should be completed and no new jobs fetched for a graceful stop/shutdown."""
+    maintenance_mode: bool = False
+    """Flag if job processing should be completed and no new jobs fetched for maintenance mode. """
+    maintenance_comments: str | None = None
+    """Comments for maintenance mode."""
+    edge_instance: EdgeWorker | None = None
+    """Singleton instance of the worker."""
+
+    def __init__(
+        self,
+        pid_file_path: str,
+        hostname: str,
+        queues: list[str] | None,
+        concurrency: int,
+        job_poll_interval: int,
+        heartbeat_interval: int,
+        daemon: bool = False,
+    ):
+        self.pid_file_path = pid_file_path
+        self.job_poll_interval = job_poll_interval
+        self.hb_interval = heartbeat_interval
+        self.hostname = hostname
+        self.queues = queues
+        self.concurrency = concurrency
+        self.free_concurrency = concurrency
+        self.daemon = daemon
+
+        EdgeWorker.edge_instance = self
+
+    @staticmethod
+    def signal_handler(sig: signal.Signals, frame):
+        if sig == SIG_STATUS:
+            marker_path = Path(maintenance_marker_file_path(None))
+            if marker_path.exists():
+                request = MaintenanceMarker.from_json(marker_path.read_text())
+                logger.info("Requested to set maintenance mode to %s", request.maintenance)
+                EdgeWorker.maintenance_mode = request.maintenance == "on"
+                if EdgeWorker.maintenance_mode and request.comments:
+                    logger.info("Comments: %s", request.comments)
+                    EdgeWorker.maintenance_comments = request.comments
+                marker_path.unlink()
+                # send heartbeat immediately to update state
+                if EdgeWorker.edge_instance:
+                    EdgeWorker.edge_instance.heartbeat(EdgeWorker.maintenance_comments)
+            else:
+                logger.info("Request to get status of Edge Worker received.")
+            status_path = Path(status_file_path(None))
+            status_path.write_text(
+                WorkerStatus(
+                    job_count=len(EdgeWorker.jobs),
+                    jobs=[job.edge_job.key for job in EdgeWorker.jobs],
+                    state=EdgeWorker._get_state(),
+                    maintenance=EdgeWorker.maintenance_mode,
+                    maintenance_comments=EdgeWorker.maintenance_comments,
+                    drain=EdgeWorker.drain,
+                ).json
+            )
+        else:
+            logger.info("Request to shut down Edge Worker received, waiting for jobs to complete.")
+            EdgeWorker.drain = True
+
+    def shutdown_handler(self, sig, frame):
+        logger.info("SIGTERM received. Terminating all jobs and quit")
+        for job in EdgeWorker.jobs:
+            os.killpg(job.process.pid, signal.SIGTERM)
+        EdgeWorker.drain = True
+
+    def _get_sysinfo(self) -> dict:
+        """Produce the sysinfo from worker to post to central site."""
+        return {
+            "airflow_version": airflow_version,
+            "edge_provider_version": edge_provider_version,
+            "concurrency": self.concurrency,
+            "free_concurrency": self.free_concurrency,
+        }
+
+    @staticmethod
+    def _get_state() -> EdgeWorkerState:
+        """State of the Edge Worker."""
+        if EdgeWorker.jobs:
+            if EdgeWorker.drain:
+                return EdgeWorkerState.TERMINATING
+            if EdgeWorker.maintenance_mode:
+                return EdgeWorkerState.MAINTENANCE_PENDING
+            return EdgeWorkerState.RUNNING
+
+        if EdgeWorker.drain:
+            if EdgeWorker.maintenance_mode:
+                return EdgeWorkerState.OFFLINE_MAINTENANCE
+            return EdgeWorkerState.OFFLINE
+
+        if EdgeWorker.maintenance_mode:
+            return EdgeWorkerState.MAINTENANCE_MODE
+        return EdgeWorkerState.IDLE
+
+    def _launch_job_af3(self, edge_job: EdgeJobFetched) -> tuple[Process, Path]:
+        if TYPE_CHECKING:
+            from airflow.executors.workloads import ExecuteTask
+
+        def _run_job_via_supervisor(
+            workload: ExecuteTask,
+        ) -> int:
+            from setproctitle import setproctitle
+
+            from airflow.sdk.execution_time.supervisor import supervise
+
+            # Ignore ctrl-c in this process -- we don't want to kill _this_ one. we let tasks run to completion
+            signal.signal(signal.SIGINT, signal.SIG_IGN)
+
+            logger.info("Worker starting up pid=%d", os.getpid())
+            setproctitle(f"airflow edge worker: {workload.ti.key}")
+
+            try:
+                base_url = conf.get("api", "base_url", fallback="/")
+                # If it's a relative URL, use localhost:8080 as the default
+                if base_url.startswith("/"):
+                    base_url = f"http://localhost:8080{base_url}"
+                default_execution_api_server = f"{base_url.rstrip('/')}/execution/"
+
+                supervise(
+                    # This is the "wrong" ti type, but it duck types the same. TODO: Create a protocol for this.
+                    # Same like in airflow/executors/local_executor.py:_execute_work()
+                    ti=workload.ti,  # type: ignore[arg-type]
+                    dag_rel_path=workload.dag_rel_path,
+                    bundle_info=workload.bundle_info,
+                    token=workload.token,
+                    server=conf.get(
+                        "core", "execution_api_server_url", fallback=default_execution_api_server
+                    ),
+                    log_path=workload.log_path,
+                )
+                return 0
+            except Exception as e:
+                logger.exception("Task execution failed: %s", e)
+                return 1
+
+        workload: ExecuteTask = edge_job.command
+        process = Process(
+            target=_run_job_via_supervisor,
+            kwargs={"workload": workload},
+        )
+        process.start()
+        base_log_folder = conf.get("logging", "base_log_folder", fallback="NOT AVAILABLE")
+        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
+
+    def _launch_job_af2_10(self, 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
+
+    def _launch_job(self, edge_job: EdgeJobFetched):
+        """Get the received job executed."""
+        process: Popen | Process
+        if AIRFLOW_V_3_0_PLUS:
+            process, logfile = self._launch_job_af3(edge_job)
+        else:
+            # Airflow 2.10
+            process, logfile = self._launch_job_af2_10(edge_job)
+        EdgeWorker.jobs.append(Job(edge_job, process, logfile, 0))
+
+    def start(self):
+        """Start the execution in a loop until terminated."""
+        try:
+            self.last_hb = worker_register(
+                self.hostname, EdgeWorkerState.STARTING, self.queues, self._get_sysinfo()
+            ).last_update
+        except EdgeWorkerVersionException as e:
+            logger.info("Version mismatch of Edge worker and Core. Shutting down worker.")
+            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.")
+            raise SystemExit(str(e))
+        if not self.daemon:
+            write_pid_to_pidfile(self.pid_file_path)
+        signal.signal(signal.SIGINT, EdgeWorker.signal_handler)
+        signal.signal(SIG_STATUS, EdgeWorker.signal_handler)
+        signal.signal(signal.SIGTERM, self.shutdown_handler)
+        os.environ["HOSTNAME"] = self.hostname
+        os.environ["AIRFLOW__CORE__HOSTNAME_CALLABLE"] = f"{_edge_hostname.__module__}._edge_hostname"
+        try:
+            self.worker_state_changed = self.heartbeat()
+            self.last_hb = datetime.now()
+            while not EdgeWorker.drain or EdgeWorker.jobs:
+                self.loop()
+
+            logger.info("Quitting worker, signal being offline.")
+            try:
+                worker_set_state(
+                    self.hostname,
+                    EdgeWorkerState.OFFLINE_MAINTENANCE
+                    if EdgeWorker.maintenance_mode
+                    else EdgeWorkerState.OFFLINE,
+                    0,
+                    self.queues,
+                    self._get_sysinfo(),
+                )
+            except EdgeWorkerVersionException:
+                logger.info("Version mismatch of Edge worker and Core. Quitting worker anyway.")
+        finally:
+            if not self.daemon:
+                remove_existing_pidfile(self.pid_file_path)
+
+    def loop(self):
+        """Run a loop of scheduling and monitoring tasks."""
+        new_job = False
+        previous_jobs = EdgeWorker.jobs
+        if not any((EdgeWorker.drain, EdgeWorker.maintenance_mode)) and self.free_concurrency > 0:
+            new_job = self.fetch_job()
+        self.check_running_jobs()
+
+        if (
+            EdgeWorker.drain
+            or datetime.now().timestamp() - self.last_hb.timestamp() > self.hb_interval
+            or self.worker_state_changed  # send heartbeat immediately if the state is different in db
+            or bool(previous_jobs) != bool(EdgeWorker.jobs)  # when number of jobs changes from/to 0
+        ):
+            self.worker_state_changed = self.heartbeat()
+            self.last_hb = datetime.now()
+
+        if not new_job:
+            self.interruptible_sleep()
+
+    def fetch_job(self) -> bool:
+        """Fetch and start a new job from central site."""
+        logger.debug("Attempting to fetch a new job...")
+        edge_job = jobs_fetch(self.hostname, self.queues, self.free_concurrency)
+        if edge_job:
+            logger.info("Received job: %s", edge_job)
+            self._launch_job(edge_job)
+            jobs_set_state(edge_job.key, TaskInstanceState.RUNNING)
+            return True
+
+        logger.info(
+            "No new job to process%s",
+            f", {len(EdgeWorker.jobs)} still running" if EdgeWorker.jobs else "",
+        )
+        return False
+
+    def check_running_jobs(self) -> None:
+        """Check which of the running tasks/jobs are completed and report back."""
+        used_concurrency = 0
+        for i in range(len(EdgeWorker.jobs) - 1, -1, -1):
+            job = EdgeWorker.jobs[i]
+            if not job.is_running:
+                EdgeWorker.jobs.remove(job)
+                if job.is_success:
+                    logger.info("Job completed: %s", job.edge_job)
+                    jobs_set_state(job.edge_job.key, TaskInstanceState.SUCCESS)
+                else:
+                    logger.error("Job failed: %s", job.edge_job)
+                    jobs_set_state(job.edge_job.key, TaskInstanceState.FAILED)
+            else:
+                used_concurrency += job.edge_job.concurrency_slots
+
+            if job.logfile.exists() and job.logfile.stat().st_size > job.logsize:
+                with job.logfile.open("rb") as logfile:
+                    push_log_chunk_size = conf.getint("edge", "push_log_chunk_size")
+                    logfile.seek(job.logsize, os.SEEK_SET)
+                    read_data = logfile.read()
+                    job.logsize += len(read_data)
+                    # backslashreplace to keep not decoded characters and not raising exception
+                    # replace null with question mark to fix issue during DB push
+                    log_data = read_data.decode(errors="backslashreplace").replace("\x00", "\ufffd")
+                    while True:
+                        chunk_data = log_data[:push_log_chunk_size]
+                        log_data = log_data[push_log_chunk_size:]
+                        if not chunk_data:
+                            break
+
+                        logs_push(
+                            task=job.edge_job.key,
+                            log_chunk_time=timezone.utcnow(),
+                            log_chunk_data=chunk_data,
+                        )
+
+        self.free_concurrency = self.concurrency - used_concurrency
+
+    def heartbeat(self, new_maintenance_comments: str | None = None) -> bool:
+        """Report liveness state of worker to central site with stats."""
+        state = EdgeWorker._get_state()
+        sysinfo = self._get_sysinfo()
+        worker_state_changed: bool = False
+        try:
+            worker_info = worker_set_state(
+                self.hostname,
+                state,
+                len(EdgeWorker.jobs),
+                self.queues,
+                sysinfo,
+                new_maintenance_comments,
+            )
+            self.queues = worker_info.queues
+            if worker_info.state == EdgeWorkerState.MAINTENANCE_REQUEST:
+                logger.info("Maintenance mode requested!")
+                EdgeWorker.maintenance_mode = True
+            elif (
+                worker_info.state in [EdgeWorkerState.IDLE, EdgeWorkerState.RUNNING]
+                and EdgeWorker.maintenance_mode
+            ):
+                logger.info("Exit Maintenance mode requested!")
+                EdgeWorker.maintenance_mode = False
+            if EdgeWorker.maintenance_mode:
+                EdgeWorker.maintenance_comments = worker_info.maintenance_comments
+            else:
+                EdgeWorker.maintenance_comments = None
+            if worker_info.state == EdgeWorkerState.SHUTDOWN_REQUEST:
+                logger.info("Shutdown requested!")
+                EdgeWorker.drain = True
+
+            worker_state_changed = worker_info.state != state
+        except EdgeWorkerVersionException:
+            logger.info("Version mismatch of Edge worker and Core. Shutting down worker.")
+            EdgeWorker.drain = True
+        return worker_state_changed
+
+    def interruptible_sleep(self):
+        """Sleeps but stops sleeping if drain is made."""
+        drain_before_sleep = EdgeWorker.drain
+        for _ in range(0, self.job_poll_interval * 10):
+            sleep(0.1)
+            if drain_before_sleep != EdgeWorker.drain:
+                return

airflow/providers/edge3/example_dags/win_notepad.py

@@ -41,7 +41,7 @@ if TYPE_CHECKING:
 
 
 class NotepadOperator(BaseOperator):
-    """Example Operator Implementation which starts a Notepod.exe on WIndows."""
+    """Example Operator Implementation which starts a ``Notepad.exe`` on Windows."""
 
     template_fields: Sequence[str] = "text"
 

airflow/providers/edge3/executors/edge_executor.py

@@ -47,9 +47,10 @@ if TYPE_CHECKING:
 
     from sqlalchemy.engine.base import Engine
 
-    from airflow.executors.base_executor import CommandType
     from airflow.models.taskinstancekey import TaskInstanceKey
 
+    # TODO: Airflow 2 type hints; remove when Airflow 2 support is removed
+    CommandType = Sequence[str]
     # Task tuple to send to be executed
     TaskTuple = tuple[TaskInstanceKey, CommandType, Optional[str], Optional[Any]]
 
@@ -72,12 +73,23 @@ class EdgeExecutor(BaseExecutor):
         inspector = inspect(engine)
         edge_job_columns = None
         with contextlib.suppress(NoSuchTableError):
-            edge_job_columns = [column["name"] for column in inspector.get_columns("edge_job")]
+            edge_job_schema = inspector.get_columns("edge_job")
+            edge_job_columns = [column["name"] for column in edge_job_schema]
+            for column in edge_job_schema:
+                if column["name"] == "command":
+                    edge_job_command_len = column["type"].length
 
         # version 0.6.0rc1 added new column concurrency_slots
         if edge_job_columns and "concurrency_slots" not in edge_job_columns:
             EdgeJobModel.metadata.drop_all(engine, tables=[EdgeJobModel.__table__])
 
+        # version 1.1.0 the command column was changed to VARCHAR(2048)
+        elif edge_job_command_len and edge_job_command_len != 2048:
+            with Session(engine) as session:
+                query = "ALTER TABLE edge_job ALTER COLUMN command TYPE VARCHAR(2048);"
+                session.execute(text(query))
+                session.commit()
+
         edge_worker_columns = None
         with contextlib.suppress(NoSuchTableError):
             edge_worker_columns = [column["name"] for column in inspector.get_columns("edge_worker")]
@@ -108,7 +120,7 @@ class EdgeExecutor(BaseExecutor):
         Store queued_tasks in own var to be able to access this in execute_async function.
         """
         self.edge_queued_tasks = deepcopy(self.queued_tasks)
-        super()._process_tasks(task_tuples)
+        super()._process_tasks(task_tuples)  # type: ignore[misc]
 
     @provide_session
     def execute_async(
@@ -122,10 +134,11 @@ class EdgeExecutor(BaseExecutor):
         """Execute asynchronously. Airflow 2.10 entry point to execute a task."""
         # Use of a temponary trick to get task instance, will be changed with Airflow 3.0.0
         # code works together with _process_tasks overwrite to get task instance.
-        task_instance = self.edge_queued_tasks[key][3]  # TaskInstance in fourth element
+        # 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)
+        self.validate_airflow_tasks_run_command(command)  # type: ignore[attr-defined]
         session.add(
             EdgeJobModel(
                 dag_id=key.dag_id,

airflow/providers/edge3/models/edge_job.py

@@ -49,7 +49,7 @@ class EdgeJobModel(Base, LoggingMixin):
     state = Column(String(20))
     queue = Column(String(256))
     concurrency_slots = Column(Integer)
-    command = Column(String(1000))
+    command = Column(String(2048))
     queued_dttm = Column(UtcDateTime)
     edge_worker = Column(String(64))
     last_update = Column(UtcDateTime)

airflow/providers/edge3/models/edge_worker.py

@@ -245,7 +245,11 @@ def remove_worker(worker_name: str, session: Session = NEW_SESSION) -> None:
     """Remove a worker that is offline or just gone from DB."""
     query = select(EdgeWorkerModel).where(EdgeWorkerModel.worker_name == worker_name)
     worker: EdgeWorkerModel = session.scalar(query)
-    if worker.state in (EdgeWorkerState.OFFLINE, EdgeWorkerState.OFFLINE_MAINTENANCE):
+    if worker.state in (
+        EdgeWorkerState.OFFLINE,
+        EdgeWorkerState.OFFLINE_MAINTENANCE,
+        EdgeWorkerState.UNKNOWN,
+    ):
         session.execute(delete(EdgeWorkerModel).where(EdgeWorkerModel.worker_name == worker_name))
     else:
         error_message = f"Cannot remove edge worker {worker_name} as it is in {worker.state} state!"

{apache_airflow_providers_edge3-1.1.0rc1.dist-info → apache_airflow_providers_edge3-1.1.1rc1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: apache-airflow-providers-edge3
-Version: 1.1.0rc1
+Version: 1.1.1rc1
 Summary: Provider package apache-airflow-providers-edge3 for Apache Airflow
 Keywords: airflow-provider,edge3,airflow,integration
 Author-email: Apache Software Foundation <dev@airflow.apache.org>
@@ -25,8 +25,8 @@ Requires-Dist: apache-airflow-providers-fab>=1.5.3rc1
 Requires-Dist: pydantic>=2.11.0
 Requires-Dist: retryhttp>=1.2.0,!=1.3.0
 Project-URL: Bug Tracker, https://github.com/apache/airflow/issues
-Project-URL: Changelog, https://airflow.staged.apache.org/docs/apache-airflow-providers-edge3/1.1.0/changelog.html
-Project-URL: Documentation, https://airflow.staged.apache.org/docs/apache-airflow-providers-edge3/1.1.0
+Project-URL: Changelog, https://airflow.staged.apache.org/docs/apache-airflow-providers-edge3/1.1.1/changelog.html
+Project-URL: Documentation, https://airflow.staged.apache.org/docs/apache-airflow-providers-edge3/1.1.1
 Project-URL: Mastodon, https://fosstodon.org/@airflow
 Project-URL: Slack Chat, https://s.apache.org/airflow-slack
 Project-URL: Source Code, https://github.com/apache/airflow
@@ -57,7 +57,7 @@ Project-URL: YouTube, https://www.youtube.com/channel/UCSXwxpWZQ7XZ1WL3wqevChA/
 
 Package ``apache-airflow-providers-edge3``
 
-Release: ``1.1.0``
+Release: ``1.1.1``
 
 
 Handle edge workers on remote sites via HTTP(s) connection and orchestrates work over distributed sites.
@@ -82,7 +82,7 @@ This is a provider package for ``edge3`` provider. All classes for this provider
 are in ``airflow.providers.edge3`` python package.
 
 You can find package information and changelog for the provider
-in the `documentation <https://airflow.apache.org/docs/apache-airflow-providers-edge3/1.1.0/>`_.
+in the `documentation <https://airflow.apache.org/docs/apache-airflow-providers-edge3/1.1.1/>`_.
 
 Installation
 ------------
@@ -125,5 +125,5 @@ Dependent package
 ==============================================================================================  =======
 
 The changelog for the provider package can be found in the
-`changelog <https://airflow.apache.org/docs/apache-airflow-providers-edge3/1.1.0/changelog.html>`_.
+`changelog <https://airflow.apache.org/docs/apache-airflow-providers-edge3/1.1.1/changelog.html>`_.
 

{apache_airflow_providers_edge3-1.1.0rc1.dist-info → apache_airflow_providers_edge3-1.1.1rc1.dist-info}/RECORD

@@ -1,21 +1,23 @@
 airflow/providers/edge3/LICENSE,sha256=gXPVwptPlW1TJ4HSuG5OMPg-a3h43OGMkZRR1rpwfJA,10850
-airflow/providers/edge3/__init__.py,sha256=NrV-3Uc00pr80NbPVUZWK9JYceO_jK26xp9BmvwFGnU,1494
+airflow/providers/edge3/__init__.py,sha256=lWNqnEBB7q4ggTGo6urdvAwUV0msxvtkIHymUhwdweg,1494
 airflow/providers/edge3/get_provider_info.py,sha256=Ek27-dB4UALHUFYoYjtoQIGq0p7zeHcEgmELHvpVmCU,6836
 airflow/providers/edge3/version_compat.py,sha256=j5PCtXvZ71aBjixu-EFTNtVDPsngzzs7os0ZQDgFVDk,1536
 airflow/providers/edge3/cli/__init__.py,sha256=9hdXHABrVpkbpjZgUft39kOFL2xSGeG4GEua0Hmelus,785
 airflow/providers/edge3/cli/api_client.py,sha256=334KHVB4eMSzRpQ5emS56o-RTUJQprxf5Q3xQldCHDQ,7440
 airflow/providers/edge3/cli/dataclasses.py,sha256=JUuvvmzSVWvG9uOEfzLIiXrTZ-HbESvu50jkPpVIYVw,2895
-airflow/providers/edge3/cli/edge_command.py,sha256=dRKC1VPAUIvJnzvPlmcT98oBGlG0_MK7TBTNvjDEI2k,35658
+airflow/providers/edge3/cli/edge_command.py,sha256=Yggt-hBcf3rq7cMelsP0Jx9QfSkR07YU229ZIc7pZYY,18276
+airflow/providers/edge3/cli/signalling.py,sha256=sf4S6j6OoP0bLkda3UlCmlZabjv5wsMypy3kAvx56Z0,3220
+airflow/providers/edge3/cli/worker.py,sha256=AqyvJyH5hn4dumt5iP_XEdiJ94F8KaYz4rVlZQR-y8E,17212
 airflow/providers/edge3/example_dags/__init__.py,sha256=9hdXHABrVpkbpjZgUft39kOFL2xSGeG4GEua0Hmelus,785
 airflow/providers/edge3/example_dags/integration_test.py,sha256=kevxwDePjTRqLWJGV-nKEQQWb7qb-y2oedm3mdqi6-8,6127
-airflow/providers/edge3/example_dags/win_notepad.py,sha256=2evbqiupi5Ko4tyRkIEC5TPbc2c0wyR2YpsDYsBLMMM,2828
+airflow/providers/edge3/example_dags/win_notepad.py,sha256=zYcrKqODN4KLZQ-5wNnZQQskrDd5LA-nKJNgKQDntSE,2832
 airflow/providers/edge3/example_dags/win_test.py,sha256=GegWqjvbsSdbsA_f3S9_FRYftVO0pggXwQQggB9Vvz4,13220
 airflow/providers/edge3/executors/__init__.py,sha256=y830gGSKCvjOcLwLuCDp84NCrHWWB9RSSH1qvJpFhyY,923
-airflow/providers/edge3/executors/edge_executor.py,sha256=Z7q1Ph_SvAuT1cR4YYcEmKYt4Yi711q65VrzofQ5t1A,15791
+airflow/providers/edge3/executors/edge_executor.py,sha256=bCdLaknCo3LIuwpYw1u68xMedDXvVaqG4ZG0QKeM7xU,16474
 airflow/providers/edge3/models/__init__.py,sha256=9hdXHABrVpkbpjZgUft39kOFL2xSGeG4GEua0Hmelus,785
-airflow/providers/edge3/models/edge_job.py,sha256=rdl9cH1bBrc7id8zkZ7uxsCJNPLG-8o9cnspGwBPBcQ,3167
+airflow/providers/edge3/models/edge_job.py,sha256=3D5HAzcVkyI2bxl3pVbbRxjIz--Tnr_eNFiw2oI6gEQ,3167
 airflow/providers/edge3/models/edge_logs.py,sha256=bNstp7gR54O2vbxzz4NTL0erbifFbGUjZ-YOM0I4sqk,2768
-airflow/providers/edge3/models/edge_worker.py,sha256=7U74k24xw36X8gQkrac3yWbtFBHbopvmRIWsjpFY8Og,10693
+airflow/providers/edge3/models/edge_worker.py,sha256=4qr5K-QU5yTd2p3AtdVhWlbvToxFFBWk2qIRFpJToWo,10749
 airflow/providers/edge3/openapi/__init__.py,sha256=0O-WvmDx8GeKSoECpHYrbe0hW-LgjlKny3VqTCpBQeQ,927
 airflow/providers/edge3/openapi/edge_worker_api_v1.yaml,sha256=GAE2IdOXmcUueNy5KFkLBgNpoWnOjnHT9TrW5NZEWpI,24938
 airflow/providers/edge3/plugins/__init__.py,sha256=9hdXHABrVpkbpjZgUft39kOFL2xSGeG4GEua0Hmelus,785
@@ -33,7 +35,7 @@ airflow/providers/edge3/worker_api/routes/health.py,sha256=XxqIppnRA138Q6mAHCdyL
 airflow/providers/edge3/worker_api/routes/jobs.py,sha256=UK1w6nXEUadOLwE9abZ4jHH4KtbvXcwaAF0EnwSa3y4,5733
 airflow/providers/edge3/worker_api/routes/logs.py,sha256=uk0SZ5hAimj3sAcq1FYCDu0AXYNeTeyjZDGBvw-986E,4945
 airflow/providers/edge3/worker_api/routes/worker.py,sha256=BGARu1RZ74lW9X-ltuMYbbVXczm_MZdqHaai2MhDWtY,8969
-apache_airflow_providers_edge3-1.1.0rc1.dist-info/entry_points.txt,sha256=7WUIGfd3o9NvvbK5trbZxNXTgYGc6pqg74wZPigbx5o,206
-apache_airflow_providers_edge3-1.1.0rc1.dist-info/WHEEL,sha256=G2gURzTEtmeR8nrdXUJfNiB3VYVxigPQ-bEQujpNiNs,82
-apache_airflow_providers_edge3-1.1.0rc1.dist-info/METADATA,sha256=3kJ3dEUkqjhppUJvNuD0I4r7MOg0pZ1kjmWcOrOARS0,5876
-apache_airflow_providers_edge3-1.1.0rc1.dist-info/RECORD,,
+apache_airflow_providers_edge3-1.1.1rc1.dist-info/entry_points.txt,sha256=7WUIGfd3o9NvvbK5trbZxNXTgYGc6pqg74wZPigbx5o,206
+apache_airflow_providers_edge3-1.1.1rc1.dist-info/WHEEL,sha256=G2gURzTEtmeR8nrdXUJfNiB3VYVxigPQ-bEQujpNiNs,82
+apache_airflow_providers_edge3-1.1.1rc1.dist-info/METADATA,sha256=FSMB2NwsD5pBBbwSBx3BQVnvPXLrLp9YVnJQR1BTf_o,5876
+apache_airflow_providers_edge3-1.1.1rc1.dist-info/RECORD,,