airflow-systemd 0.1.0__py3-none-any.whl

airflow_systemd/__init__.py

@@ -0,0 +1,6 @@
+from systemd_pydantic import *
+
+from .airflow import *
+from .config import *
+
+__version__ = "0.1.0"

airflow_systemd/airflow/__init__.py

@@ -0,0 +1,3 @@
+from .local import Systemd
+
+__all__ = ("Systemd",)

airflow_systemd/airflow/local.py

@@ -0,0 +1,245 @@
+from logging import getLogger
+from typing import TYPE_CHECKING, Any, Literal
+
+from airflow_pydantic import Pool, fail, skip
+from systemd_pydantic import SystemdClient
+from systemd_pydantic.convenience import (
+    SystemdTaskStep,
+    check_services,
+    remove_systemd_config,
+    restart_services,
+    start_services,
+    stop_services,
+    write_systemd_config,
+)
+
+from airflow_systemd.config.systemd import SystemdAirflowConfiguration
+
+if TYPE_CHECKING:
+    from airflow_ha import CheckResult, HighAvailabilityOperator
+
+    DAG = Any
+    Operator = Any
+
+__all__ = ("Systemd",)
+
+_log = getLogger(__name__)
+Step = SystemdTaskStep | Literal["force-kill"]
+
+
+def _python_operator() -> Any:
+    from airflow_pydantic.airflow import PythonOperator
+
+    return PythonOperator
+
+
+class Systemd:
+    """Airflow task group for a locally managed systemd job."""
+
+    def __init__(self, dag: "DAG", cfg: SystemdAirflowConfiguration | dict, **kwargs: Any):
+        if isinstance(cfg, dict):
+            cfg = SystemdAirflowConfiguration.model_validate(cfg)
+
+        self._cfg = cfg
+        self._pool = cfg.pool.pool if isinstance(cfg.pool, Pool) else cfg.pool
+        self._systemd_client = kwargs.pop("systemd_client", SystemdClient(cfg))
+        self._dag = dag
+
+        self.setup_dag()
+        self.initialize_tasks()
+
+        self.configure_systemd >> self.start_services >> self.check_services
+        self.check_services.retrigger_fail >> self.restart_services
+        self.check_services.stop_pass >> self.stop_services >> self.unconfigure_systemd
+
+        self._force_kill = self.get_step_operator("force-kill")
+
+        PythonOperator = _python_operator()
+
+        (
+            PythonOperator(
+                task_id=f"{self._dag.dag_id}-force-kill-dag",
+                python_callable=skip,
+                **self.get_base_operator_kwargs(),
+            )
+            >> self._force_kill
+        )
+
+        any_config_fail = PythonOperator(
+            task_id=f"{self._dag.dag_id}-check-config-failed",
+            python_callable=fail,
+            trigger_rule="one_failed",
+            **self.get_base_operator_kwargs(),
+        )
+        self.configure_systemd >> any_config_fail
+        self.start_services >> any_config_fail
+        self.stop_services >> any_config_fail
+        self.unconfigure_systemd >> any_config_fail
+
+    def setup_dag(self) -> None:
+        self._dag.catchup = False
+        self._dag.concurrency = 1
+        self._dag.max_active_tasks = 1
+        self._dag.max_active_runs = 1
+
+    def initialize_tasks(self) -> None:
+        PythonOperator = _python_operator()
+
+        self._check_services = self.get_step_operator("check-services")
+        self._configure_systemd = self.get_step_operator("configure-systemd")
+        self._start_services = self.get_step_operator("start-services")
+        if self._cfg.stop_on_exit:
+            self._stop_services = self.get_step_operator("stop-services")
+            if self._cfg.cleanup:
+                self._unconfigure_systemd = self.get_step_operator("unconfigure-systemd")
+            else:
+                self._unconfigure_systemd = PythonOperator(
+                    task_id=f"{self._dag.dag_id}-unconfigure-systemd",
+                    python_callable=skip,
+                    **self.get_base_operator_kwargs(),
+                )
+        else:
+            self._stop_services = PythonOperator(
+                task_id=f"{self._dag.dag_id}-stop-services",
+                python_callable=skip,
+                **self.get_base_operator_kwargs(),
+            )
+            self._unconfigure_systemd = PythonOperator(
+                task_id=f"{self._dag.dag_id}-unconfigure-systemd",
+                python_callable=skip,
+                **self.get_base_operator_kwargs(),
+            )
+        self._restart_services = self.get_step_operator("restart-services")
+
+    @property
+    def configure_systemd(self) -> "Operator":
+        return self._configure_systemd
+
+    @property
+    def start_services(self) -> "Operator":
+        return self._start_services
+
+    @property
+    def check_services(self) -> "HighAvailabilityOperator":
+        return self._check_services
+
+    @property
+    def stop_services(self) -> "Operator":
+        return self._stop_services
+
+    @property
+    def restart_services(self) -> "Operator":
+        return self._restart_services
+
+    @property
+    def unconfigure_systemd(self) -> "Operator":
+        return self._unconfigure_systemd
+
+    @property
+    def systemd_client(self) -> SystemdClient:
+        return self._systemd_client
+
+    def get_base_operator_kwargs(self) -> dict[str, Any]:
+        return {"dag": self._dag, "pool": self._pool}
+
+    def get_step_kwargs(self, step: Step) -> dict[str, Any]:
+        cfg = self._cfg
+        if step == "configure-systemd":
+            return {
+                "python_callable": lambda **kwargs: (
+                    self.check_services.check_end_conditions(**kwargs) is None
+                    and write_systemd_config(cfg.model_dump_json(exclude_unset=True), _exit=False)
+                ),
+                "do_xcom_push": True,
+            }
+        if step == "start-services":
+
+            def _start_services(**kwargs: Any) -> bool:
+                if self.check_services.check_end_conditions(**kwargs) is not None:
+                    return False
+                restart = cfg.restart_on_retrigger or (cfg.restart_on_initial and self.check_services.is_initial_run(**kwargs))
+                return start_services(cfg._pydantic_path, restart=restart, _exit=False)
+
+            return {
+                "python_callable": _start_services,
+                "do_xcom_push": True,
+            }
+        if step == "stop-services":
+            return {"python_callable": lambda: stop_services(cfg._pydantic_path, _exit=False), "do_xcom_push": True}
+        if step == "check-services":
+
+            def _check_services(systemd_cfg: SystemdAirflowConfiguration = cfg, **kwargs: Any) -> "CheckResult":
+                from airflow_ha import Action, Result
+
+                if check_services(systemd_cfg._pydantic_path, check_done=True, _exit=False):
+                    return Result.PASS, Action.STOP
+                if check_services(systemd_cfg._pydantic_path, check_running=True, _exit=False):
+                    return Result.PASS, Action.CONTINUE
+                if check_services(systemd_cfg._pydantic_path, _exit=False):
+                    return Result.PASS, Action.CONTINUE
+                return Result.FAIL, Action.RETRIGGER
+
+            return {"python_callable": _check_services, "do_xcom_push": True}
+        if step == "restart-services":
+            return {"python_callable": lambda: restart_services(cfg._pydantic_path, _exit=False), "do_xcom_push": True}
+        if step == "unconfigure-systemd":
+            return {"python_callable": lambda: remove_systemd_config(cfg._pydantic_path, _exit=False), "do_xcom_push": True}
+        if step == "force-kill":
+            return {
+                "python_callable": lambda: all(info.stopped() for info in self.systemd_client.kill_services().values()),
+                "do_xcom_push": True,
+            }
+        raise NotImplementedError(f"Unknown step: {step}")
+
+    def get_step_operator(self, step: Step) -> "Operator":
+        from airflow_ha import HighAvailabilityOperator
+
+        PythonOperator = _python_operator()
+
+        if step == "check-services":
+            return HighAvailabilityOperator(
+                task_id=f"{self._dag.dag_id}-{step}",
+                poke_interval=self._cfg.check_interval.total_seconds(),
+                timeout=self._cfg.check_timeout.total_seconds(),
+                mode="poke",
+                runtime=self._cfg.runtime,
+                endtime=self._cfg.endtime,
+                maxretrigger=self._cfg.maxretrigger,
+                reference_date=self._cfg.reference_date,
+                **self.get_base_operator_kwargs(),
+                **self.get_step_kwargs(step),
+            )
+        return PythonOperator(
+            task_id=f"{self._dag.dag_id}-{step}",
+            **self.get_base_operator_kwargs(),
+            **self.get_step_kwargs(step),
+        )
+
+    def __lshift__(self, other: "Operator") -> "Operator":
+        self.configure_systemd << other
+        return self.unconfigure_systemd
+
+    def __rshift__(self, other: "Operator") -> "Operator":
+        self.unconfigure_systemd >> other
+        return other
+
+    def set_upstream(self, other: "Operator") -> None:
+        self.configure_systemd.set_upstream(other)
+
+    def set_downstream(self, other: "Operator") -> None:
+        self.unconfigure_systemd.set_downstream(other)
+
+    def update_relative(self, other: "Operator", upstream: bool = True, edge_modifier: Any = None) -> "Systemd":
+        if upstream:
+            self.configure_systemd.update_relative(other, upstream=True, edge_modifier=edge_modifier)
+        else:
+            self.unconfigure_systemd.update_relative(other, upstream=False, edge_modifier=edge_modifier)
+        return self
+
+    @property
+    def leaves(self):
+        return self.unconfigure_systemd.leaves
+
+    @property
+    def roots(self):
+        return self.configure_systemd.roots

airflow_systemd/config/__init__.py

@@ -0,0 +1,2 @@
+from .systemd import *
+from .task import *

airflow_systemd/config/systemd.py

@@ -0,0 +1,32 @@
+from datetime import time, timedelta
+from typing import Literal
+
+from airflow_pydantic import Pool
+from pydantic import Field
+from systemd_pydantic import SystemdConvenienceConfiguration
+
+__all__ = ("SystemdAirflowConfiguration", "load_airflow_config")
+
+
+class SystemdAirflowConfiguration(SystemdConvenienceConfiguration):
+    """Systemd configuration for an Airflow-managed job."""
+
+    check_interval: timedelta = Field(default=timedelta(seconds=5), description="Interval between service status checks")
+    check_timeout: timedelta = Field(default=timedelta(hours=8), description="Timeout for service status checks")
+
+    runtime: timedelta | None = Field(default=None, description="Maximum runtime of the systemd job")
+    endtime: time | None = Field(default=None, description="End time of the systemd job")
+    maxretrigger: int | None = Field(default=None, description="Maximum number of service check retriggers")
+    reference_date: Literal["start_date", "logical_date", "data_interval_end"] = Field(
+        default="data_interval_end",
+        description="Date used to evaluate runtime and endtime",
+    )
+
+    pool: str | Pool | None = Field(default=None, description="Airflow pool for systemd tasks")
+    stop_on_exit: bool = Field(default=True, description="Stop services when the DAG finishes")
+    cleanup: bool = Field(default=True, description="Remove generated unit files when the DAG finishes")
+    restart_on_initial: bool = Field(default=False, description="Restart services on an initial Airflow run")
+    restart_on_retrigger: bool = Field(default=False, description="Restart services when airflow-ha retriggers the job")
+
+
+load_airflow_config = SystemdAirflowConfiguration.load

airflow_systemd/config/task.py

@@ -0,0 +1,31 @@
+from typing import Type
+
+from airflow_pydantic import ImportPath, Task, TaskArgs
+from pydantic import Field, field_validator
+
+from .systemd import SystemdAirflowConfiguration
+
+__all__ = ("SystemdOperator", "SystemdOperatorArgs", "SystemdTask", "SystemdTaskArgs")
+
+
+class SystemdTaskArgs(TaskArgs):
+    cfg: SystemdAirflowConfiguration
+
+
+SystemdOperatorArgs = SystemdTaskArgs
+
+
+class SystemdTask(Task, SystemdTaskArgs):
+    operator: ImportPath = Field(default="airflow_systemd.Systemd", validate_default=True)
+
+    @field_validator("operator")
+    @classmethod
+    def validate_operator(cls, value: Type) -> Type:
+        from airflow_systemd.airflow import Systemd
+
+        if value is not Systemd:
+            raise ValueError(f"operator must be 'airflow_systemd.Systemd', got: {value}")
+        return value
+
+
+SystemdOperator = SystemdTask

airflow_systemd/tests/conftest.py

@@ -0,0 +1,20 @@
+from pathlib import Path
+
+import pytest
+
+from airflow_systemd import ServiceConfiguration, ServiceUnitConfiguration, SystemdAirflowConfiguration
+
+
+@pytest.fixture
+def systemd_airflow_configuration(tmp_path: Path) -> SystemdAirflowConfiguration:
+    return SystemdAirflowConfiguration(
+        service={
+            "test": ServiceUnitConfiguration(
+                service=ServiceConfiguration(type="exec", exec_start="/bin/echo hello"),
+            )
+        },
+        unit_dir=tmp_path / "units",
+        working_dir=tmp_path / "state",
+        scope="user",
+        pool="test-pool",
+    )

airflow_systemd/tests/test_config.py

@@ -0,0 +1,17 @@
+from datetime import timedelta
+
+from airflow_systemd import SystemdAirflowConfiguration
+
+
+def test_airflow_configuration_defaults(systemd_airflow_configuration: SystemdAirflowConfiguration):
+    assert systemd_airflow_configuration.check_interval == timedelta(seconds=5)
+    assert systemd_airflow_configuration.check_timeout == timedelta(hours=8)
+    assert systemd_airflow_configuration.stop_on_exit is True
+    assert systemd_airflow_configuration.cleanup is True
+
+
+def test_airflow_configuration_roundtrip(systemd_airflow_configuration: SystemdAirflowConfiguration):
+    value = SystemdAirflowConfiguration.model_validate_json(systemd_airflow_configuration.model_dump_json())
+
+    assert value == systemd_airflow_configuration
+    assert value._pydantic_path == systemd_airflow_configuration._pydantic_path

airflow_systemd/tests/test_local.py

@@ -0,0 +1,130 @@
+from typing import Any
+from unittest.mock import Mock, patch
+
+import pytest
+from airflow_pydantic import airflow as airflow_compat
+from airflow_pydantic.migration import _airflow_3
+
+from airflow_systemd import SystemdAirflowConfiguration
+
+DAG: Any = airflow_compat.DAG
+
+
+@pytest.mark.skipif(_airflow_3() is None, reason="Airflow not installed")
+class TestSystemd:
+    @staticmethod
+    def create_systemd(systemd_airflow_configuration: SystemdAirflowConfiguration, dag_id: str = "systemd-callbacks"):
+        from airflow_systemd import Systemd
+
+        return Systemd(dag=DAG(dag_id=dag_id, schedule=None), cfg=systemd_airflow_configuration)
+
+    def test_task_graph(self, systemd_airflow_configuration: SystemdAirflowConfiguration):
+        from airflow_systemd import Systemd
+
+        dag = DAG(dag_id="systemd-test", default_args={}, schedule=None, params={})
+        systemd = Systemd(dag=dag, cfg=systemd_airflow_configuration)
+
+        assert systemd.configure_systemd in dag.tasks
+        assert systemd.start_services in dag.tasks
+        assert systemd.check_services in dag.tasks
+        assert systemd.restart_services in dag.tasks
+        assert systemd.stop_services in dag.tasks
+        assert systemd.unconfigure_systemd in dag.tasks
+        assert dag.catchup is False
+        assert dag.max_active_tasks == 1
+        assert dag.max_active_runs == 1
+
+    @pytest.mark.parametrize(("stop_on_exit", "cleanup"), [(False, False), (True, False)])
+    def test_optional_cleanup(
+        self,
+        systemd_airflow_configuration: SystemdAirflowConfiguration,
+        stop_on_exit: bool,
+        cleanup: bool,
+    ):
+        from airflow_systemd import Systemd
+
+        cfg = systemd_airflow_configuration.model_copy(update={"stop_on_exit": stop_on_exit, "cleanup": cleanup})
+        dag = DAG(dag_id=f"systemd-cleanup-{stop_on_exit}-{cleanup}", schedule=None)
+        systemd = Systemd(dag=dag, cfg=cfg)
+
+        assert systemd.stop_services is not None
+        assert systemd.unconfigure_systemd is not None
+
+    def test_dict_configuration(self, systemd_airflow_configuration: SystemdAirflowConfiguration):
+        from airflow_systemd import Systemd
+
+        dag = DAG(dag_id="systemd-dict", schedule=None)
+        systemd = Systemd(dag=dag, cfg=systemd_airflow_configuration.model_dump())
+
+        assert systemd._cfg == systemd_airflow_configuration
+
+    def test_lifecycle_callbacks(self, systemd_airflow_configuration: SystemdAirflowConfiguration):
+        from airflow_ha import Action, Result
+
+        systemd = self.create_systemd(systemd_airflow_configuration)
+        systemd.check_services._check_end_conditions = Mock(return_value=None)
+        systemd._cfg.restart_on_retrigger = True
+
+        with (
+            patch("airflow_systemd.airflow.local.write_systemd_config", return_value=True) as write,
+            patch("airflow_systemd.airflow.local.start_services", return_value=True) as start,
+            patch("airflow_systemd.airflow.local.stop_services", return_value=True) as stop,
+            patch("airflow_systemd.airflow.local.restart_services", return_value=True) as restart,
+            patch("airflow_systemd.airflow.local.remove_systemd_config", return_value=True) as remove,
+        ):
+            assert systemd.get_step_kwargs("configure-systemd")["python_callable"]() is True
+            assert systemd.get_step_kwargs("start-services")["python_callable"]() is True
+            assert systemd.get_step_kwargs("stop-services")["python_callable"]() is True
+            assert systemd.get_step_kwargs("restart-services")["python_callable"]() is True
+            assert systemd.get_step_kwargs("unconfigure-systemd")["python_callable"]() is True
+
+        write.assert_called_once()
+        start.assert_called_once_with(systemd._cfg._pydantic_path, restart=True, _exit=False)
+        stop.assert_called_once()
+        restart.assert_called_once()
+        remove.assert_called_once()
+
+        systemd.check_services._check_end_conditions.return_value = "done"
+        assert systemd.get_step_kwargs("start-services")["python_callable"]() is False
+
+        check = systemd.get_step_kwargs("check-services")["python_callable"]
+        with patch("airflow_systemd.airflow.local.check_services", side_effect=[True]):
+            assert check() == (Result.PASS, Action.STOP)
+        with patch("airflow_systemd.airflow.local.check_services", side_effect=[False, True]):
+            assert check() == (Result.PASS, Action.CONTINUE)
+        with patch("airflow_systemd.airflow.local.check_services", side_effect=[False, False, True]):
+            assert check() == (Result.PASS, Action.CONTINUE)
+        with patch("airflow_systemd.airflow.local.check_services", side_effect=[False, False, False]):
+            assert check() == (Result.FAIL, Action.RETRIGGER)
+
+    def test_force_kill(self, systemd_airflow_configuration: SystemdAirflowConfiguration):
+        info = Mock()
+        info.stopped.return_value = True
+        client = Mock()
+        client.kill_services.return_value = {"test.service": info}
+
+        from airflow_systemd import Systemd
+
+        systemd = Systemd(
+            dag=DAG(dag_id="systemd-force-kill", schedule=None),
+            cfg=systemd_airflow_configuration,
+            systemd_client=client,
+        )
+
+        assert systemd.systemd_client is client
+        assert systemd.get_step_kwargs("force-kill")["python_callable"]() is True
+
+    def test_chaining_helpers(self, systemd_airflow_configuration: SystemdAirflowConfiguration):
+        systemd = self.create_systemd(systemd_airflow_configuration, "systemd-chaining")
+        PythonOperator: Any = airflow_compat.PythonOperator
+        before = PythonOperator(task_id="before", python_callable=lambda: None, dag=systemd._dag)
+        after = PythonOperator(task_id="after", python_callable=lambda: None, dag=systemd._dag)
+
+        assert systemd << before is systemd.unconfigure_systemd
+        assert systemd >> after is after
+        systemd.set_upstream(before)
+        systemd.set_downstream(after)
+        assert systemd.update_relative(before) is systemd
+        assert systemd.update_relative(after, upstream=False) is systemd
+        assert systemd.roots
+        assert systemd.leaves

airflow_systemd/tests/test_task.py

@@ -0,0 +1,34 @@
+import pytest
+from pydantic import ValidationError
+
+from airflow_systemd import (
+    Systemd,
+    SystemdAirflowConfiguration,
+    SystemdOperator,
+    SystemdOperatorArgs,
+    SystemdTask,
+    SystemdTaskArgs,
+)
+
+
+def test_task_args(systemd_airflow_configuration: SystemdAirflowConfiguration):
+    args = SystemdTaskArgs(cfg=systemd_airflow_configuration)
+
+    assert args.cfg == systemd_airflow_configuration
+    assert SystemdOperatorArgs is SystemdTaskArgs
+
+
+def test_task_default_operator(systemd_airflow_configuration: SystemdAirflowConfiguration):
+    task = SystemdTask(task_id="systemd-task", cfg=systemd_airflow_configuration)
+
+    assert task.operator is Systemd
+    assert SystemdOperator is SystemdTask
+
+
+def test_task_rejects_another_operator(systemd_airflow_configuration: SystemdAirflowConfiguration):
+    with pytest.raises(ValidationError, match="operator must be"):
+        SystemdTask(
+            task_id="systemd-task",
+            cfg=systemd_airflow_configuration,
+            operator="airflow_systemd.SystemdTask",
+        )

airflow_systemd-0.1.0.dist-info/METADATA

@@ -0,0 +1,97 @@
+Metadata-Version: 2.4
+Name: airflow-systemd
+Version: 0.1.0
+Summary: Systemd operators and configuration for long-running tasks
+Project-URL: Repository, https://github.com/airflow-laminar/airflow-systemd
+Project-URL: Homepage, https://github.com/airflow-laminar/airflow-systemd
+Author-email: the airflow-systemd authors <t.paine154@gmail.com>
+License: Apache-2.0
+License-File: LICENSE
+Classifier: Development Status :: 3 - Alpha
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Programming Language :: Python :: Implementation :: CPython
+Classifier: Programming Language :: Python :: Implementation :: PyPy
+Requires-Python: >=3.11
+Requires-Dist: airflow-ha<1.7,>=1.4.1
+Requires-Dist: airflow-pydantic<1.6,>=1.5.5
+Requires-Dist: systemd-pydantic<0.2,>=0.1
+Provides-Extra: airflow
+Requires-Dist: apache-airflow-providers-ssh; extra == 'airflow'
+Requires-Dist: apache-airflow-providers-standard; extra == 'airflow'
+Requires-Dist: apache-airflow<3,>=2.8; extra == 'airflow'
+Provides-Extra: airflow3
+Requires-Dist: apache-airflow-providers-ssh; extra == 'airflow3'
+Requires-Dist: apache-airflow-providers-standard; extra == 'airflow3'
+Requires-Dist: apache-airflow<3.2,>=3; extra == 'airflow3'
+Provides-Extra: develop
+Requires-Dist: airflow-config>=0.1.2; extra == 'develop'
+Requires-Dist: airflow-pydantic; extra == 'develop'
+Requires-Dist: build; extra == 'develop'
+Requires-Dist: bump-my-version; extra == 'develop'
+Requires-Dist: check-dist; extra == 'develop'
+Requires-Dist: codespell; extra == 'develop'
+Requires-Dist: hatchling; extra == 'develop'
+Requires-Dist: mdformat; extra == 'develop'
+Requires-Dist: mdformat-tables>=1; extra == 'develop'
+Requires-Dist: pytest; extra == 'develop'
+Requires-Dist: pytest-cov; extra == 'develop'
+Requires-Dist: ruff; extra == 'develop'
+Requires-Dist: systemd-pydantic<0.2,>=0.1; extra == 'develop'
+Requires-Dist: twine; extra == 'develop'
+Requires-Dist: ty; extra == 'develop'
+Requires-Dist: uv; extra == 'develop'
+Requires-Dist: wheel; extra == 'develop'
+Description-Content-Type: text/markdown
+
+# airflow-systemd
+
+Systemd operators and configuration for long-running tasks
+
+[![Build Status](https://github.com/airflow-laminar/airflow-systemd/actions/workflows/build.yaml/badge.svg?branch=main&event=push)](https://github.com/airflow-laminar/airflow-systemd/actions/workflows/build.yaml)
+[![codecov](https://codecov.io/gh/airflow-laminar/airflow-systemd/branch/main/graph/badge.svg)](https://codecov.io/gh/airflow-laminar/airflow-systemd)
+[![License](https://img.shields.io/github/license/airflow-laminar/airflow-systemd)](https://github.com/airflow-laminar/airflow-systemd)
+[![PyPI](https://img.shields.io/pypi/v/airflow-systemd.svg)](https://pypi.python.org/pypi/airflow-systemd)
+
+## Overview
+
+`airflow-systemd` mirrors `airflow-supervisor` for hosts managed by systemd. It turns a
+`SystemdAirflowConfiguration` into an Airflow task lifecycle:
+
+```text
+configure-systemd -> start-services -> check-services
+                                      |             |
+                                      v             v
+                               restart-services  stop-services -> unconfigure-systemd
+```
+
+Airflow owns scheduling, so this integration runs service units directly rather than
+starting systemd timer units. Timer models remain available through `systemd-pydantic`
+for non-Airflow consumers.
+
+```python
+from airflow import DAG
+from airflow_systemd import ServiceConfiguration, ServiceUnitConfiguration, Systemd, SystemdAirflowConfiguration
+
+dag = DAG(dag_id="long-running-job", schedule="@daily")
+config = SystemdAirflowConfiguration(
+    service={
+        "long-running-job": ServiceUnitConfiguration(
+            service=ServiceConfiguration(type="exec", exec_start="/opt/jobs/run"),
+        )
+    },
+    scope="user",
+)
+Systemd(dag=dag, cfg=config)
+```
+
+The local integration supports the same Airflow-specific controls as
+`airflow-supervisor`: status interval and timeout, runtime/end-time limits, retrigger
+limits, pools, optional restart behavior, stop-on-exit, and cleanup.
+
+> [!NOTE]
+> This library was generated using [copier](https://copier.readthedocs.io/en/stable/) from the [Base Python Project Template repository](https://github.com/python-project-templates/base).

airflow_systemd-0.1.0.dist-info/RECORD

@@ -0,0 +1,14 @@
+airflow_systemd/__init__.py,sha256=u2uYJSDKSmzemPxrz4OpCDZAjRObxrwD9YYLlLrEx7c,100
+airflow_systemd/airflow/__init__.py,sha256=KlJLB8A6p5UBTmW4eKKDsfJJagA_wuepncMSaBbCn0A,51
+airflow_systemd/airflow/local.py,sha256=du8Zgm1FBSolos0iuTkhrd1hhcXm78FVyntQ43pqUnc,9170
+airflow_systemd/config/__init__.py,sha256=ozSxE2f7AUO7qO8ZYe27P8iF4COc75VsItYdlkSq-nk,43
+airflow_systemd/config/systemd.py,sha256=if_0ZqwkSLlIzcpOxyXNwmYVDp3k-ub75iqODUZY6fg,1704
+airflow_systemd/config/task.py,sha256=_eCzcNmUmItiXrtR_l14jSJT6ekiJksgCQdzYpBWYFg,843
+airflow_systemd/tests/conftest.py,sha256=js_MyXw-IckLWz265iAsILB1PMtX0d3mJ2ajs2mUSqY,594
+airflow_systemd/tests/test_config.py,sha256=A8PJ9JGON6UtYqmTOSRYkTwZ5R9pRYR4A9rxx0fjSr4,811
+airflow_systemd/tests/test_local.py,sha256=XNUES5hTPWj-09gPLZ688CMU89jxxgYy6YbHSgXY7sY,6217
+airflow_systemd/tests/test_task.py,sha256=8ab6aeSDlPRyFXF5txIt7TrCW50710su22eItswHtzE,1052
+airflow_systemd-0.1.0.dist-info/METADATA,sha256=EfrSj2kWkv-HyahSOFICZNB_uC_VIRhbGf0HRcilelE,4493
+airflow_systemd-0.1.0.dist-info/WHEEL,sha256=lCkmxWfQsSc9CfIClYeavTdQeEX2toPqufh9gI35EQA,87
+airflow_systemd-0.1.0.dist-info/licenses/LICENSE,sha256=-YGoOCaxwBBL4djlUIyh_lKK8JgE2g5svYa2VEpZUUs,11357
+airflow_systemd-0.1.0.dist-info/RECORD,,

airflow_systemd-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.31.0
+Root-Is-Purelib: true
+Tag: py3-none-any

airflow_systemd-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright 2025 the airflow-systemd authors
+
+   Licensed 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.