python-rundeck 0.1.0__py3-none-any.whl

rundeck/v1/objects/executions.py

@@ -0,0 +1,327 @@
+"""
+Gestion des exécutions Rundeck
+"""
+
+from typing import Any
+
+from rundeck.base import RundeckObject, RundeckObjectManager
+
+
+class Execution(RundeckObject):
+    """Représente une exécution Rundeck"""
+
+    _id_attr = "id"
+
+    def abort(self, asUser: str | None = None) -> dict[str, Any]:
+        """
+        Annule l'exécution
+
+        Args:
+            asUser: Annuler en tant qu'utilisateur
+
+        Returns:
+            Statut de l'annulation
+        """
+        path = f"/execution/{self.id}/abort"
+
+        data = {}
+        if asUser:
+            data["asUser"] = asUser
+
+        return self.manager.rd.http_get(path, params=data)
+
+    def get_output(
+        self,
+        offset: int = 0,
+        lastlines: int | None = None,
+        lastmod: int | None = None,
+        maxlines: int | None = None,
+    ) -> dict[str, Any]:
+        """
+        Récupère la sortie de l'exécution
+
+        Args:
+            offset: Offset dans la sortie
+            lastlines: Nombre de dernières lignes
+            lastmod: Timestamp de dernière modification
+            maxlines: Nombre maximum de lignes
+
+        Returns:
+            Sortie de l'exécution
+        """
+        path = f"/execution/{self.id}/output"
+
+        params: dict[str, Any] = {"offset": offset}
+        if lastlines:
+            params["lastlines"] = lastlines
+        if lastmod:
+            params["lastmod"] = lastmod
+        if maxlines:
+            params["maxlines"] = maxlines
+
+        return self.manager.rd.http_get(path, params=params)
+
+    def get_state(self) -> dict[str, Any]:
+        """
+        Récupère l'état de l'exécution
+
+        Returns:
+            État de l'exécution
+        """
+        path = f"/execution/{self.id}/state"
+        return self.manager.rd.http_get(path)
+
+    def delete(self) -> None:
+        """Supprime l'exécution"""
+        self.manager.delete(self.id)
+
+    def is_running(self) -> bool:
+        """
+        Vérifie si l'exécution est en cours
+
+        Returns:
+            True si en cours, False sinon
+        """
+        return self._attrs.get("status") == "running"
+
+    def is_succeeded(self) -> bool:
+        """
+        Vérifie si l'exécution a réussi
+
+        Returns:
+            True si réussie, False sinon
+        """
+        return self._attrs.get("status") == "succeeded"
+
+    def is_failed(self) -> bool:
+        """
+        Vérifie si l'exécution a échoué
+
+        Returns:
+            True si échouée, False sinon
+        """
+        return self._attrs.get("status") in ("failed", "failed-with-retry")
+
+    def is_aborted(self) -> bool:
+        """
+        Vérifie si l'exécution a été annulée
+
+        Returns:
+            True si annulée, False sinon
+        """
+        return self._attrs.get("status") == "aborted"
+
+    def refresh(self) -> "Execution":
+        """
+        Actualise les données de l'exécution
+
+        Returns:
+            Exécution actualisée
+        """
+        updated = self.manager.get(self.id)
+        self._attrs = updated._attrs
+        return self
+
+
+class ExecutionManager(RundeckObjectManager):
+    """Manager pour les exécutions"""
+
+    _path = "/executions"
+    _obj_cls = Execution
+
+    def list(
+        self,
+        project: str | None = None,
+        status: str | None = None,
+        max: int | None = None,
+        offset: int | None = None,
+        **kwargs: Any,
+    ) -> "list[Execution]":
+        """
+        Liste les exécutions
+
+        Args:
+            project: Filtre par projet
+            status: Filtre par statut
+            max: Nombre maximum de résultats
+            offset: Offset de pagination
+            **kwargs: Autres paramètres de filtrage
+
+        Returns:
+            Liste d'exécutions
+        """
+        project_name = project or (
+            self.parent.id if getattr(self, "parent", None) else None
+        )
+        if project_name:
+            path = f"/project/{project_name}/executions"
+        else:
+            path = self._build_path()
+
+        params: dict[str, Any] = {}
+        if status:
+            params["status"] = status
+        if max:
+            params["max"] = max
+        if offset:
+            params["offset"] = offset
+        params.update(kwargs)
+
+        return self._list(path=path, params=params or None)
+
+    def running(self, project: str | None = None) -> "list[Execution]":
+        """
+        Liste les exécutions en cours
+
+        Args:
+            project: Filtre par projet (ou '*' pour tous)
+
+        Returns:
+            Liste d'exécutions en cours
+        """
+        project_name = project or (
+            self.parent.id if getattr(self, "parent", None) else None
+        )
+        if project_name:
+            path = f"/project/{project_name}/executions/running"
+        else:
+            path = "/project/*/executions/running"
+
+        return self._list(path=path)
+
+    def get(self, id: str) -> Execution:
+        """
+        Récupère une exécution par son ID
+
+        Args:
+            id: ID de l'exécution
+
+        Returns:
+            Exécution
+        """
+        path = f"/execution/{id}"
+        return self._get(id, path=path)
+
+    def delete(self, id: str) -> None:
+        """
+        Supprime une exécution
+
+        Args:
+            id: ID de l'exécution
+        """
+        path = f"/execution/{id}"
+        self._delete(id, path=path)
+
+    def bulk_delete(self, ids: "list[str]") -> dict[str, Any]:
+        """
+        Supprime plusieurs exécutions
+
+        Args:
+            ids: Liste d'IDs d'exécutions
+
+        Returns:
+            Résultat de la suppression
+        """
+        path = self._build_path("delete")
+        data = {"ids": ids}
+        return self.rd.http_post(path, json=data)
+
+    def query(
+        self,
+        project: str,
+        statusFilter: str | None = None,
+        abortedbyFilter: str | None = None,
+        userFilter: str | None = None,
+        recentFilter: str | None = None,
+        olderFilter: str | None = None,
+        begin: str | None = None,
+        end: str | None = None,
+        adhoc: bool | None = None,
+        jobIdListFilter: "list[str] | None" = None,
+        excludeJobIdListFilter: "list[str] | None" = None,
+        jobListFilter: "list[str] | None" = None,
+        excludeJobListFilter: "list[str] | None" = None,
+        groupPath: str | None = None,
+        groupPathExact: str | None = None,
+        excludeGroupPath: str | None = None,
+        excludeGroupPathExact: str | None = None,
+        jobExactFilter: str | None = None,
+        excludeJobExactFilter: str | None = None,
+        max: int | None = None,
+        offset: int | None = None,
+    ) -> "list[Execution]":
+        """
+        Requête avancée sur les exécutions
+
+        Args:
+            project: Nom du projet
+            statusFilter: Filtre par statut
+            abortedbyFilter: Filtre par utilisateur ayant annulé
+            userFilter: Filtre par utilisateur
+            recentFilter: Filtre par période récente
+            olderFilter: Filtre par période ancienne
+            begin: Date de début
+            end: Date de fin
+            adhoc: Exécutions adhoc uniquement
+            jobIdListFilter: Liste d'IDs de jobs
+            excludeJobIdListFilter: Exclure les IDs de jobs
+            jobListFilter: Liste de noms de jobs
+            excludeJobListFilter: Exclure les noms de jobs
+            groupPath: Chemin de groupe
+            groupPathExact: Chemin de groupe exact
+            excludeGroupPath: Exclure le chemin de groupe
+            excludeGroupPathExact: Exclure le chemin de groupe exact
+            jobExactFilter: Nom exact du job
+            excludeJobExactFilter: Exclure le nom exact du job
+            max: Nombre maximum de résultats
+            offset: Offset de pagination
+
+        Returns:
+            Liste d'exécutions
+        """
+        path = f"/project/{project}/executions"
+
+        params: dict[str, Any] = {}
+        if statusFilter:
+            params["statusFilter"] = statusFilter
+        if abortedbyFilter:
+            params["abortedbyFilter"] = abortedbyFilter
+        if userFilter:
+            params["userFilter"] = userFilter
+        if recentFilter:
+            params["recentFilter"] = recentFilter
+        if olderFilter:
+            params["olderFilter"] = olderFilter
+        if begin:
+            params["begin"] = begin
+        if end:
+            params["end"] = end
+        if adhoc is not None:
+            params["adhoc"] = "true" if adhoc else "false"
+        if jobIdListFilter:
+            params["jobIdListFilter"] = ",".join(jobIdListFilter)
+        if excludeJobIdListFilter:
+            params["excludeJobIdListFilter"] = ",".join(excludeJobIdListFilter)
+        if jobListFilter:
+            params["jobListFilter"] = ",".join(jobListFilter)
+        if excludeJobListFilter:
+            params["excludeJobListFilter"] = ",".join(excludeJobListFilter)
+        if groupPath:
+            params["groupPath"] = groupPath
+        if groupPathExact:
+            params["groupPathExact"] = groupPathExact
+        if excludeGroupPath:
+            params["excludeGroupPath"] = excludeGroupPath
+        if excludeGroupPathExact:
+            params["excludeGroupPathExact"] = excludeGroupPathExact
+        if jobExactFilter:
+            params["jobExactFilter"] = jobExactFilter
+        if excludeJobExactFilter:
+            params["excludeJobExactFilter"] = excludeJobExactFilter
+        if max:
+            params["max"] = max
+        if offset:
+            params["offset"] = offset
+
+        result = self.rd.http_list(path, params=params)
+        return [self._obj_cls(self, item) for item in result]

rundeck/v1/objects/features.py

@@ -0,0 +1,44 @@
+"""
+Gestion des system features (/feature).
+"""
+
+from rundeck.base import RundeckObject, RundeckObjectManager
+
+
+class Feature(RundeckObject):
+    """Représente un feature flag système."""
+
+    _id_attr = "name"
+    _repr_attr = "name"
+
+
+class FeatureManager(RundeckObjectManager[Feature]):
+    """Manager pour interroger les features système."""
+
+    _path = "/feature"
+    _obj_cls = Feature
+
+    def list(self) -> list[Feature]:
+        """Liste le statut de tous les features système."""
+        base = self._build_path()
+        path = f"{base.rstrip('/')}/"
+        result = self.rd.http_get(path)
+        items = []
+        if isinstance(result, dict):
+            for name, value in result.items():
+                if isinstance(value, dict):
+                    items.append({"name": name, **(value or {})})
+                else:
+                    items.append({"name": name, "enabled": bool(value)})
+        return self._wrap_list(items)
+
+    def get(self, name: str) -> Feature:
+        """Récupère le statut d'un feature spécifique."""
+        path = self._build_path(name)
+        data = self.rd.http_get(path)
+        if isinstance(data, dict):
+            data.setdefault("name", name)
+        return self._wrap(data)
+
+
+__all__ = ["Feature", "FeatureManager"]

rundeck/v1/objects/jobs.py

@@ -0,0 +1,329 @@
+"""
+Gestion des jobs Rundeck
+"""
+
+from typing import Any
+
+from rundeck.base import RundeckObject, RundeckObjectManager
+from rundeck.v1.objects.executions import Execution
+from rundeck.v1.objects.scm import JobSCMManager
+
+
+class Job(RundeckObject):
+    """Représente un job Rundeck."""
+
+    _id_attr = "id"
+    _repr_attr = "name"
+
+    def _job_path(self, suffix: str | None = None) -> str:
+        """Construit le chemin de base /job/{id} avec suffixe optionnel."""
+        base = f"/job/{self.id}"
+        if suffix:
+            return f"{base}/{suffix.lstrip('/')}"
+        return base
+
+    def run(self, **kwargs: Any) -> Execution:
+        """
+        Exécute le job et retourne l'exécution.
+        """
+        path = self._job_path("run")
+        result = self.rd.http_post(path, json=kwargs or None)
+        # Wrap avec le manager d'exécutions existant.
+        return Execution(self.manager.rd.executions, result)
+
+    def retry(self, execution_id: str, **kwargs: Any) -> Execution:
+        """
+        Relance une exécution (retry).
+        """
+        path = self._job_path(f"retry/{execution_id}")
+        result = self.rd.http_post(path, json=kwargs or None)
+        return Execution(self.manager.rd.executions, result)
+
+    def delete(self) -> None:
+        """Supprime le job courant."""
+        self.manager.delete(self.id)
+
+    def definition(self, format: str = "json") -> Any:
+        """Récupère la définition du job dans le format demandé."""
+        path = self._job_path()
+        return self.rd.http_get(path, params={"format": format})
+
+    def enable_execution(self) -> Any:
+        """Active l'exécution pour ce job."""
+        path = self._job_path("execution/enable")
+        return self.rd.http_post(path)
+
+    def disable_execution(self) -> Any:
+        """Désactive l'exécution pour ce job."""
+        path = self._job_path("execution/disable")
+        return self.rd.http_post(path)
+
+    def enable_schedule(self) -> Any:
+        """Active la planification pour ce job."""
+        path = self._job_path("schedule/enable")
+        return self.rd.http_post(path)
+
+    def disable_schedule(self) -> Any:
+        """Désactive la planification pour ce job."""
+        path = self._job_path("schedule/disable")
+        return self.rd.http_post(path)
+
+    def info(self) -> dict[str, Any]:
+        """Récupère les métadonnées du job."""
+        path = self._job_path("info")
+        return self.rd.http_get(path)
+
+    def workflow(self) -> dict[str, Any]:
+        """Récupère le workflow du job."""
+        path = self._job_path("workflow")
+        return self.rd.http_get(path)
+
+    def meta(self, meta: str | None = None) -> list[dict[str, Any]]:
+        """
+        Récupère les métadonnées UI du job (endpoint /job/{id}/meta).
+
+        Args:
+            meta: Liste de métadonnées à inclure (ex: "name,description")
+                ou "*" pour tout.
+        """
+        params = {"meta": meta} if meta else None
+        path = self._job_path("meta")
+        return self.rd.http_get(path, params=params)
+
+    def tags(self) -> list[str]:
+        """Retourne les tags du job (commercial, endpoint /job/{id}/tags)."""
+        path = self._job_path("tags")
+        return self.rd.http_get(path)
+
+    def upload_option_file(
+        self,
+        option_name: str,
+        content: bytes | str,
+        file_name: str | None = None,
+    ) -> dict[str, Any]:
+        """
+        Upload d'un fichier pour une option (single file).
+        """
+        path = self._job_path("input/file")
+        params = {"optionName": option_name}
+        if file_name:
+            params["fileName"] = file_name
+        response = self.rd.http_post(
+            path,
+            params=params,
+            data=content,
+            headers={
+                "Content-Type": "application/octet-stream",
+                "Accept": "application/json",
+            },
+            raw=True,
+        )
+        return response.json()
+
+    def upload_option_files(
+        self, files: dict[str, tuple[str, bytes | Any]]
+    ) -> dict[str, Any]:
+        """
+        Upload multi-fichiers pour des options (multipart/form-data).
+
+        Args:
+            files: mapping option_name -> (file_name, content)
+        """
+        multipart: dict[str, tuple[str, bytes | Any]] = {
+            f"option.{name}": (fname, data) for name, (fname, data) in files.items()
+        }
+        path = self._job_path("input/file")
+        response = self.rd.http_post(
+            path,
+            files=multipart,
+            headers={"Accept": "application/json"},
+            raw=True,
+        )
+        return response.json()
+
+    def list_uploaded_files(
+        self,
+        max: int | None = None,
+        offset: int | None = None,
+        file_state: str | None = None,
+    ) -> dict[str, Any]:
+        """
+        Liste les fichiers uploadés pour ce job.
+        """
+        params: dict[str, Any] = {}
+        if max is not None:
+            params["max"] = max
+        if offset is not None:
+            params["offset"] = offset
+        if file_state:
+            params["fileState"] = file_state
+        path = f"/job/{self.id}/input/files"
+        return self.rd.http_get(path, params=params or None)
+
+    def forecast(
+        self, time: str | None = None, max: int | None = None
+    ) -> dict[str, Any]:
+        """Prévision du planning du job (scheduler/forecast)."""
+        params: dict[str, Any] = {}
+        if time:
+            params["time"] = time
+        if max:
+            params["max"] = max
+        path = f"/scheduler/{self._job_path('forecast').lstrip('/')}"
+        return self.rd.http_get(path, params=params)
+
+    @property
+    def scm(self) -> JobSCMManager:
+        """Accès aux opérations SCM pour ce job."""
+        return JobSCMManager(self.rd, parent=self)
+
+
+class JobBulkManager(RundeckObjectManager[Job]):
+    """Opérations bulk sur les jobs (/jobs/*)."""
+
+    _path = "/jobs"
+    _obj_cls = Job
+
+    def enable_execution(self, ids: "list[str]") -> Any:
+        """Active l'exécution pour plusieurs jobs."""
+        data = {"ids": ids}
+        path = self._build_path("execution/enable")
+        return self.rd.http_put(path, json=data)
+
+    def disable_execution(self, ids: "list[str]") -> Any:
+        """Désactive l'exécution pour plusieurs jobs."""
+        data = {"ids": ids}
+        path = self._build_path("execution/disable")
+        return self.rd.http_put(path, json=data)
+
+    def enable_schedule(self, ids: "list[str]") -> Any:
+        """Active la planification pour plusieurs jobs."""
+        data = {"ids": ids}
+        path = self._build_path("schedule/enable")
+        return self.rd.http_post(path, json=data)
+
+    def disable_schedule(self, ids: "list[str]") -> Any:
+        """Désactive la planification pour plusieurs jobs."""
+        data = {"ids": ids}
+        path = self._build_path("schedule/disable")
+        return self.rd.http_post(path, json=data)
+
+    def delete(self, ids: "list[str]") -> Any:
+        """Supprime plusieurs jobs en une requête."""
+        data = {"ids": ids}
+        path = self._build_path("delete")
+        return self.rd.http_delete(path, json=data)
+
+
+class JobManager(RundeckObjectManager[Job]):
+    """Manager pour les jobs."""
+
+    _path = "/project/{parent}/jobs"
+    _obj_cls = Job
+
+    def __init__(self, rd: Any, parent: RundeckObject | None = None) -> None:
+        super().__init__(rd, parent)
+        self.bulk = JobBulkManager(rd)
+
+    def __getattr__(self, name: str) -> Any:
+        # Alias pour permettre rd.jobs.import(...) malgré le mot-clé Python.
+        if name == "import":
+            return self.import_jobs
+        return super().__getattribute__(name)
+
+    def list(
+        self,
+        project: str | None = None,
+        **filters: Any,
+    ) -> "list[Job]":
+        """Liste les jobs d'un projet."""
+        project_name = project or (self.parent.id if self.parent else None)
+        # Avec un parent Project, on réutilise le manager parenté ; sinon on exige
+        # le nom du projet.
+        if not project_name:
+            raise ValueError("Le paramètre project est requis")
+
+        # Si le manager est parenté (project.jobs), _build_path() résout le
+        # placeholder {parent}.
+        # Sinon, on formate le chemin collection à partir du nom de projet fourni.
+        path = (
+            self._build_path()
+            if self.parent and not project
+            else self._path.format(parent=project_name)
+        )
+        return self._list(path=path, params=filters)
+
+    def get(self, id: str) -> "Job":
+        """Récupère un job par identifiant."""
+        path = f"/job/{id}"
+        return self._get(id, path=path)
+
+    def export(
+        self,
+        project: str | None = None,
+        format: str = "json",
+        idlist: str | None = None,
+        groupPath: str | None = None,
+        jobFilter: str | None = None,
+    ) -> Any:
+        """Exporte les jobs d'un projet (json/xml/yaml)."""
+        project_name = project or (self.parent.id if self.parent else None)
+        if not project_name:
+            raise ValueError("Le paramètre project est requis")
+
+        params: dict[str, Any] = {"format": format} if format else {}
+        if idlist:
+            params["idlist"] = idlist
+        if groupPath:
+            params["groupPath"] = groupPath
+        if jobFilter:
+            params["jobFilter"] = jobFilter
+
+        path = (
+            self._build_path("export")
+            if self.parent and not project
+            else f"/project/{project_name}/jobs/export"
+        )
+        return self.rd.http_get(path, params=params or None)
+
+    def import_jobs(
+        self,
+        project: str | None = None,
+        content: Any = None,
+        fileformat: str = "json",
+        dupeOption: str | None = None,
+        uuidOption: str | None = None,
+        content_type: str = "application/octet-stream",
+    ) -> Any:
+        """Importe des jobs (json/xml/yaml) dans un projet."""
+        project_name = project or (self.parent.id if self.parent else None)
+        if not project_name:
+            raise ValueError("Le paramètre project est requis")
+
+        params: dict[str, Any] = {"fileformat": fileformat} if fileformat else {}
+        if dupeOption:
+            params["dupeOption"] = dupeOption
+        if uuidOption:
+            params["uuidOption"] = uuidOption
+
+        path = (
+            self._build_path("import")
+            if self.parent and not project
+            else f"/project/{project_name}/jobs/import"
+        )
+        return self.rd.http_post(
+            path,
+            params=params or None,
+            data=content,
+            headers={"Content-Type": content_type},
+        )
+
+    def delete(self, id: str) -> None:
+        """Supprime un job par identifiant."""
+        path = f"/job/{id}"
+        self._delete(id, path=path)
+
+    def get_uploaded_file_info(self, file_id: str) -> dict[str, Any]:
+        """Récupère les métadonnées d'un fichier uploadé (par ID)."""
+        path = f"/jobs/file/{file_id}"
+        return self.rd.http_get(path)