python-rundeck 0.1.0__py3-none-any.whl

rundeck/v1/objects/scm.py

@@ -0,0 +1,229 @@
+"""
+Gestion des endpoints SCM (import/export) pour les projets et jobs.
+"""
+
+from typing import Any
+
+from rundeck.base import RundeckObjectManager
+
+
+class _ProjectSCMBaseManager(RundeckObjectManager):
+    """Base pour les sous-managers SCM projet (intègre l'intégration import/export)."""
+
+    def __init__(self, rd: Any, parent: Any, integration: str) -> None:
+        super().__init__(rd, parent)
+        self.integration = integration
+
+    def _base_path(self) -> str:
+        if not self.parent:
+            raise ValueError("Parent projet requis pour SCM")
+        return f"/project/{self.parent.id}/scm/{self.integration}"
+
+
+class ProjectSCMPluginsManager(_ProjectSCMBaseManager):
+    """Découverte des plugins SCM pour un projet."""
+
+    def list(self) -> Any:
+        """Liste les plugins SCM disponibles pour l'intégration."""
+        path = self._build_path("plugins")
+        return self.rd.http_get(path)
+
+    def input_fields(self, plugin_type: str) -> Any:
+        """Champs de saisie pour un plugin donné."""
+        path = self._build_path(f"plugin/{plugin_type}/input")
+        return self.rd.http_get(path)
+
+
+class ProjectSCMConfigManager(_ProjectSCMBaseManager):
+    """Configuration et cycle de vie d'un plugin SCM pour un projet."""
+
+    def setup(self, plugin_type: str, config: dict[str, Any]) -> Any:
+        """Configure un plugin SCM pour le projet."""
+        path = self._build_path(f"plugin/{plugin_type}/setup")
+        payload = {"config": config}
+        return self.rd.http_post(path, json=payload)
+
+    def enable(self, plugin_type: str) -> Any:
+        """Active le plugin SCM (idempotent)."""
+        path = self._build_path(f"plugin/{plugin_type}/enable")
+        return self.rd.http_post(path)
+
+    def disable(self, plugin_type: str) -> Any:
+        """Désactive le plugin SCM (idempotent)."""
+        path = self._build_path(f"plugin/{plugin_type}/disable")
+        return self.rd.http_post(path)
+
+    def get(self) -> Any:
+        """Récupère la configuration SCM du projet pour l'intégration."""
+        path = self._build_path("config")
+        return self.rd.http_get(path)
+
+
+class ProjectSCMActionsManager(_ProjectSCMBaseManager):
+    """Statut et actions SCM pour un projet."""
+
+    def status(self) -> Any:
+        """Statut SCM du projet pour l'intégration."""
+        path = self._build_path("status")
+        return self.rd.http_get(path)
+
+    def input_fields(self, action_id: str) -> Any:
+        """Champs attendus pour une action SCM projet."""
+        path = self._build_path(f"action/{action_id}/input")
+        return self.rd.http_get(path)
+
+    def perform(
+        self,
+        action_id: str,
+        input_values: dict[str, Any] | None = None,
+        jobs: list[str] | None = None,
+        items: list[str] | None = None,
+        deleted: list[str] | None = None,
+        deleted_jobs: list[str] | None = None,
+    ) -> Any:
+        """Exécute une action SCM projet (ex: commit/import/sync)."""
+        payload: dict[str, Any] = {}
+        if input_values is not None:
+            payload["input"] = input_values
+        if jobs:
+            payload["jobs"] = jobs
+        if items:
+            payload["items"] = items
+        if deleted:
+            payload["deleted"] = deleted
+        if deleted_jobs:
+            payload["deletedJobs"] = deleted_jobs
+
+        path = self._build_path(f"action/{action_id}")
+        return self.rd.http_post(path, json=payload or None)
+
+
+class ProjectSCMIntegrationManager(RundeckObjectManager):
+    """Regroupe les sous-managers SCM projet pour une intégration (import/export)."""
+
+    def __init__(self, rd: Any, parent: Any, integration: str) -> None:
+        super().__init__(rd, parent)
+        self.integration = integration
+
+    @property
+    def plugins(self) -> ProjectSCMPluginsManager:
+        return ProjectSCMPluginsManager(
+            self.rd, parent=self.parent, integration=self.integration
+        )
+
+    @property
+    def config(self) -> ProjectSCMConfigManager:
+        return ProjectSCMConfigManager(
+            self.rd, parent=self.parent, integration=self.integration
+        )
+
+    @property
+    def actions(self) -> ProjectSCMActionsManager:
+        return ProjectSCMActionsManager(
+            self.rd, parent=self.parent, integration=self.integration
+        )
+
+
+class ProjectSCMManager(RundeckObjectManager):
+    """Manager racine SCM pour un projet, expose import/export."""
+
+    def __init__(self, rd: Any, parent: Any) -> None:
+        if parent is None:
+            raise ValueError("Parent projet requis pour SCM")
+        super().__init__(rd, parent)
+
+    @property
+    def import_(self) -> ProjectSCMIntegrationManager:
+        """SCM import pour le projet."""
+        return ProjectSCMIntegrationManager(
+            self.rd, parent=self.parent, integration="import"
+        )
+
+    @property
+    def export(self) -> ProjectSCMIntegrationManager:
+        """SCM export pour le projet."""
+        return ProjectSCMIntegrationManager(
+            self.rd, parent=self.parent, integration="export"
+        )
+
+    def __getattr__(self, name: str) -> Any:
+        if name == "import":
+            return self.import_
+        return super().__getattribute__(name)
+
+
+class JobSCMManager(RundeckObjectManager):
+    """Manager racine SCM pour un job, expose import/export."""
+
+    def __init__(self, rd: Any, parent: Any) -> None:
+        if parent is None:
+            raise ValueError("Parent job requis pour SCM")
+        super().__init__(rd, parent)
+
+    @property
+    def import_(self) -> "JobSCMIntegrationManager":
+        """SCM import pour le job."""
+        return JobSCMIntegrationManager(
+            self.rd, parent=self.parent, integration="import"
+        )
+
+    @property
+    def export(self) -> "JobSCMIntegrationManager":
+        """SCM export pour le job."""
+        return JobSCMIntegrationManager(
+            self.rd, parent=self.parent, integration="export"
+        )
+
+    def __getattr__(self, name: str) -> Any:
+        if name == "import":
+            return self.import_
+        return super().__getattribute__(name)
+
+
+class JobSCMIntegrationManager(RundeckObjectManager):
+    """Opérations SCM pour un job donné et une intégration (import/export)."""
+
+    def __init__(self, rd: Any, parent: Any, integration: str) -> None:
+        super().__init__(rd, parent)
+        self.integration = integration
+
+    def _base_path(self) -> str:
+        if not self.parent:
+            raise ValueError("Parent job requis pour SCM")
+        return f"/job/{self.parent.id}/scm/{self.integration}"
+
+    def status(self) -> Any:
+        """Statut SCM du job pour l'intégration."""
+        path = self._build_path("status")
+        return self.rd.http_get(path)
+
+    def diff(self) -> Any:
+        """Diff SCM pour le job (si applicable)."""
+        path = self._build_path("diff")
+        return self.rd.http_get(path)
+
+    def input_fields(self, action_id: str) -> Any:
+        """Champs attendus pour une action SCM job."""
+        path = self._build_path(f"action/{action_id}/input")
+        return self.rd.http_get(path)
+
+    def perform(
+        self, action_id: str, input_values: dict[str, Any] | None = None
+    ) -> Any:
+        """Exécute une action SCM job."""
+        payload: dict[str, Any] = {}
+        if input_values is not None:
+            payload["input"] = input_values
+        path = self._build_path(f"action/{action_id}")
+        return self.rd.http_post(path, json=payload or None)
+
+
+__all__ = [
+    "ProjectSCMManager",
+    "ProjectSCMIntegrationManager",
+    "ProjectSCMPluginsManager",
+    "ProjectSCMConfigManager",
+    "ProjectSCMActionsManager",
+    "JobSCMManager",
+    "JobSCMIntegrationManager",
+]

rundeck/v1/objects/system.py

@@ -0,0 +1,140 @@
+"""
+Gestion du système Rundeck
+"""
+
+from typing import Any
+
+from rundeck.base import RundeckObject, RundeckObjectManager
+
+
+class SystemExecutionsManager(RundeckObjectManager):
+    """Sous-manager pour les endpoints executions du système."""
+
+    _path = "/system/executions"
+
+    def enable(self) -> dict[str, Any]:
+        """Active le mode d'exécution."""
+        path = self._build_path("enable")
+        return self.rd.http_post(path)
+
+    def disable(self) -> dict[str, Any]:
+        """Désactive le mode d'exécution (mode passif)."""
+        path = self._build_path("disable")
+        return self.rd.http_post(path)
+
+    def status(self) -> dict[str, Any]:
+        """Statut actuel du mode d'exécution."""
+        path = self._build_path("status")
+        return self.rd.http_get(path)
+
+
+class SystemACL(RundeckObject):
+    """Représente une policy ACL système."""
+
+    _id_attr = "name"
+    _repr_attr = "name"
+
+
+class SystemACLManager(RundeckObjectManager[SystemACL]):
+    """Sous-manager pour les endpoints ACL système."""
+
+    _path = "/system/acl"
+    _obj_cls = SystemACL
+
+    def list(self) -> list[SystemACL]:
+        """Liste les politiques ACL système."""
+        path = self._build_path("")
+        result = self.rd.http_get(path)
+        if isinstance(result, dict):
+            resources = result.get("resources") or []
+            items = []
+            for entry in resources:
+                name = entry.get("name") or entry.get("path")
+                if name:
+                    data = dict(entry)
+                    data.setdefault("name", name)
+                    items.append(data)
+            result = items
+        return self._wrap_list(result or [])
+
+    def get(self, policy_name: str) -> SystemACL:
+        """Récupère une politique ACL (contenu texte)."""
+        path = self._build_path(policy_name)
+        response = self.rd.http_get(path, raw=True)
+        return self._wrap({"name": policy_name, "content": response.text})
+
+    def create(self, policy_name: str, content: str) -> SystemACL:
+        """Crée une politique ACL système."""
+        path = self._build_path(policy_name)
+        headers = {"Content-Type": "application/yaml"}
+        result = self.rd.http_post(path, data=content, headers=headers) or {}
+        if "name" not in result:
+            result["name"] = policy_name
+        return self._wrap(result)
+
+    def update(self, policy_name: str, content: str) -> SystemACL:
+        """Met à jour une politique ACL système."""
+        path = self._build_path(policy_name)
+        headers = {"Content-Type": "application/yaml"}
+        result = self.rd.http_put(path, data=content, headers=headers) or {}
+        if "name" not in result:
+            result["name"] = policy_name
+        return self._wrap(result)
+
+    def delete(self, policy_name: str) -> None:
+        """Supprime une politique ACL système."""
+        path = self._build_path(policy_name)
+        self.rd.http_delete(path)
+
+
+class SystemLogStorageManager(RundeckObjectManager):
+    """Sous-manager pour les endpoints logstorage du système."""
+
+    _path = "/system/logstorage"
+
+    def info(self) -> dict[str, Any]:
+        """Informations sur le stockage des logs."""
+        path = self._build_path()
+        return self.rd.http_get(path)
+
+    def incomplete(self, max: int = 20, offset: int = 0) -> dict[str, Any]:
+        """Liste des exécutions avec stockage incomplet."""
+        params = {"max": max, "offset": offset}
+        path = self._build_path("incomplete")
+        return self.rd.http_get(path, params=params)
+
+    def incomplete_resume(self) -> dict[str, Any]:
+        """Reprise du traitement des logs incomplets."""
+        path = self._build_path("incomplete/resume")
+        return self.rd.http_post(path)
+
+
+class SystemManager(RundeckObjectManager):
+    """Manager pour les opérations système"""
+
+    _path = "/system"
+
+    @property
+    def executions(self) -> SystemExecutionsManager:
+        """Accès aux endpoints /system/executions/*."""
+        return SystemExecutionsManager(self.rd)
+
+    @property
+    def acl(self) -> SystemACLManager:
+        """Accès aux endpoints ACL système /system/acl/*."""
+        return SystemACLManager(self.rd)
+
+    @property
+    def logstorage(self) -> SystemLogStorageManager:
+        """Accès aux endpoints /system/logstorage/*."""
+        return SystemLogStorageManager(self.rd)
+
+    def info(self) -> dict[str, Any]:
+        """
+        Récupère les informations système
+
+        Returns:
+            Informations système
+        """
+        path = self._build_path("info")
+        return self.rd.http_get(path)

rundeck/v1/objects/tokens.py

@@ -0,0 +1,102 @@
+"""
+Gestion des tokens Rundeck
+"""
+
+from typing import Any
+
+from rundeck.base import RundeckObject, RundeckObjectManager
+
+
+class Token(RundeckObject):
+    """Représente un token API Rundeck"""
+
+    _id_attr = "id"
+    _repr_attr = "user"
+
+    def delete(self) -> None:
+        """Supprime le token"""
+        self.manager.delete(self.id)
+
+
+class TokenManager(RundeckObjectManager):
+    """Manager pour les tokens"""
+
+    _path = "/tokens"
+    _obj_cls = Token
+
+    _single_path = "/token/{id}"
+
+    def _token_path(self, token_id: str) -> str:
+        """
+        Chemin pour un token unitaire (/token/{id}).
+        L'API Rundeck mélange /tokens (collection) et /token/{id} (single),
+        on centralise ici pour rester cohérent.
+        """
+        return self._single_path.format(id=token_id)
+
+    def list(self, user: str | None = None) -> "list[Token]":
+        """
+        Liste les tokens
+
+        Args:
+            user: Filtre par utilisateur
+
+        Returns:
+            Liste de tokens
+        """
+        path = self._build_path(user) if user else self._build_path()
+        return self._list(path=path)
+
+    def get(self, token_id: str) -> Token:
+        """
+        Récupère un token par son ID
+
+        Args:
+            token_id: ID du token
+
+        Returns:
+            Token
+        """
+        path = self._token_path(token_id)
+        return self._get(token_id, path=path)
+
+    def create(
+        self,
+        user: str,
+        roles: "list[str]",
+        duration: str | None = None,
+        name: str | None = None,
+    ) -> Token:
+        """
+        Crée un nouveau token
+
+        Args:
+            user: Nom d'utilisateur
+            roles: Liste des rôles
+            duration: Durée de validité (ex: "120d")
+            name: Nom du token (API v37+)
+
+        Returns:
+            Token créé
+        """
+        data: dict[str, Any] = {
+            "user": user,
+            "roles": roles,
+        }
+        if duration:
+            data["duration"] = duration
+        if name:
+            data["name"] = name
+
+        path = self._build_path(user)
+        return self._create(json=data, path=path)
+
+    def delete(self, token_id: str) -> None:
+        """
+        Supprime un token
+
+        Args:
+            token_id: ID du token
+        """
+        path = self._token_path(token_id)
+        self._delete(token_id, path=path)

rundeck/v1/objects/users.py

@@ -0,0 +1,137 @@
+"""
+Gestion des utilisateurs Rundeck
+"""
+
+from typing import Any
+
+from rundeck.base import RundeckObject, RundeckObjectManager
+
+
+class User(RundeckObject):
+    """Représente un utilisateur Rundeck"""
+
+    _id_attr = "login"
+    _repr_attr = "login"
+
+    def update(
+        self,
+        firstName: str | None = None,
+        lastName: str | None = None,
+        email: str | None = None,
+    ) -> "User":
+        """
+        Met à jour les informations de l'utilisateur
+
+        Args:
+            firstName: Prénom
+            lastName: Nom
+            email: Email
+
+        Returns:
+            Utilisateur mis à jour
+        """
+        data: dict[str, Any] = {}
+        if firstName:
+            data["firstName"] = firstName
+        if lastName:
+            data["lastName"] = lastName
+        if email:
+            data["email"] = email
+
+        path = self.manager._build_path(f"info/{self.login}")
+        result = self.manager.rd.http_post(path, json=data)
+        self._attrs.update(result)
+        return self
+
+    def roles(self) -> list[str]:
+        """
+        Récupère les rôles de l'utilisateur
+
+        Returns:
+            Liste des rôles
+        """
+        path = self.manager._build_path("roles")
+        result = self.manager.rd.http_get(path)
+        return result.get("roles", [])
+
+
+class UserManager(RundeckObjectManager):
+    """Manager pour les utilisateurs"""
+
+    _path = "/user"
+    _obj_cls = User
+
+    def list(self) -> "list[User]":
+        """
+        Liste tous les utilisateurs
+
+        Returns:
+            Liste d'utilisateurs
+        """
+        path = self._build_path("list")
+        return self._list(path=path)
+
+    def get(self, login: str) -> User:
+        """
+        Récupère un utilisateur par son login
+
+        Args:
+            login: Login de l'utilisateur
+
+        Returns:
+            Utilisateur
+        """
+        path = self._build_path(f"info/{login}")
+        return self._get(login, path=path)
+
+    def get_current(self) -> User:
+        """
+        Récupère l'utilisateur courant
+
+        Returns:
+            Utilisateur courant
+        """
+        path = self._build_path("info")
+        return self._get("current", path=path)
+
+    def update(
+        self,
+        login: str,
+        firstName: str | None = None,
+        lastName: str | None = None,
+        email: str | None = None,
+    ) -> User:
+        """
+        Met à jour un utilisateur
+
+        Args:
+            login: Login de l'utilisateur
+            firstName: Prénom
+            lastName: Nom
+            email: Email
+
+        Returns:
+            Utilisateur mis à jour
+        """
+        data: dict[str, Any] = {}
+        if firstName:
+            data["firstName"] = firstName
+        if lastName:
+            data["lastName"] = lastName
+        if email:
+            data["email"] = email
+
+        path = self._build_path(f"info/{login}")
+        result = self.rd.http_post(path, json=data)
+        return self._obj_cls(self, result)
+
+    def current_roles(self) -> "list[str]":
+        """
+        Récupère les rôles de l'utilisateur courant
+
+        Returns:
+            Liste des rôles
+        """
+        path = self._build_path("roles")
+        result = self.rd.http_get(path)
+        return result.get("roles", [])