Add JWT authentication with user/password login, role-based access control, and Bearer token support while maintaining legacy API key compatibility for transition; update README with comprehensive JWT security guidelines, installation instructions for Python/SSH, development startup scripts (.env, run_dev.sh/ps1), and migrate all API examples to JWT authentication; update Ansible inventory SSH key paths from Docker container paths to local user paths

This commit is contained in:
2025-12-14 17:33:34 -05:00
parent 5a512d39b5
commit 0030fcc101
177 changed files with 22810 additions and 289 deletions
+23
View File
@@ -10,6 +10,18 @@ from .notification import (
NotificationResponse,
NotificationTemplates,
)
from .auth import (
LoginRequest,
Token,
TokenData,
UserBase,
UserCreate,
UserUpdate,
UserOut,
UserSetup,
PasswordChange,
AuthStatus,
)
__all__ = [
"HostCreate",
@@ -31,4 +43,15 @@ __all__ = [
"NotificationRequest",
"NotificationResponse",
"NotificationTemplates",
# Auth
"LoginRequest",
"Token",
"TokenData",
"UserBase",
"UserCreate",
"UserUpdate",
"UserOut",
"UserSetup",
"PasswordChange",
"AuthStatus",
]
+108
View File
@@ -0,0 +1,108 @@
"""
Schémas Pydantic pour l'exécution Ansible.
"""
from datetime import datetime, timezone
from typing import Optional, List, Dict, Any, Literal
from pydantic import BaseModel, Field, field_validator
class AnsibleExecutionRequest(BaseModel):
"""Requête d'exécution de playbook Ansible."""
playbook: str = Field(..., description="Nom du playbook à exécuter")
target: str = Field(default="all", description="Hôte ou groupe cible")
extra_vars: Optional[Dict[str, Any]] = Field(default=None, description="Variables supplémentaires")
check_mode: bool = Field(default=False, description="Mode dry-run (--check)")
verbose: bool = Field(default=False, description="Mode verbeux")
class AdHocCommandRequest(BaseModel):
"""Requête pour exécuter une commande ad-hoc Ansible."""
target: str = Field(..., description="Hôte ou groupe cible")
command: str = Field(..., description="Commande shell à exécuter")
module: str = Field(default="shell", description="Module Ansible (shell, command, raw)")
become: bool = Field(default=False, description="Exécuter avec sudo")
timeout: int = Field(default=60, ge=5, le=600, description="Timeout en secondes")
category: Optional[str] = Field(default="default", description="Catégorie d'historique pour cette commande")
class AdHocCommandResult(BaseModel):
"""Résultat d'une commande ad-hoc."""
target: str
command: str
success: bool
return_code: int
stdout: str
stderr: Optional[str] = None
duration: float
hosts_results: Optional[Dict[str, Any]] = None
class AdHocHistoryEntry(BaseModel):
"""Entrée dans l'historique des commandes ad-hoc."""
id: str
command: str
target: str
module: str
become: bool
category: str = "default"
description: Optional[str] = None
created_at: datetime = Field(default_factory=lambda: datetime.now(timezone.utc))
last_used: datetime = Field(default_factory=lambda: datetime.now(timezone.utc))
use_count: int = 1
class AdHocHistoryCategory(BaseModel):
"""Catégorie pour organiser les commandes ad-hoc."""
name: str
description: Optional[str] = None
color: str = "#7c3aed"
icon: str = "fa-folder"
class PlaybookInfo(BaseModel):
"""Informations sur un playbook."""
name: str
filename: str
path: str
category: str = "general"
subcategory: str = "other"
hosts: str = "all"
size: int = 0
modified: Optional[str] = None
description: Optional[str] = None
class PlaybookContentRequest(BaseModel):
"""Requête pour sauvegarder le contenu d'un playbook."""
content: str = Field(..., description="Contenu YAML du playbook")
class PlaybooksListResponse(BaseModel):
"""Réponse API pour la liste des playbooks."""
playbooks: List[PlaybookInfo] = Field(default_factory=list)
categories: Dict[str, List[str]] = Field(default_factory=dict)
ansible_dir: str = ""
filter: Optional[str] = None
class BootstrapRequest(BaseModel):
"""Requête de bootstrap pour un hôte."""
host: str = Field(..., description="Adresse IP ou hostname de l'hôte")
root_password: str = Field(..., description="Mot de passe root pour la connexion initiale")
automation_user: str = Field(default="automation", description="Nom de l'utilisateur d'automatisation à créer")
class SSHConfigResponse(BaseModel):
"""Réponse de diagnostic de la configuration SSH."""
ssh_key_path: str
ssh_dir: str
ssh_dir_exists: bool
private_key_exists: bool
public_key_exists: bool
available_files: List[str] = Field(default_factory=list)
public_keys_found: List[str] = Field(default_factory=list)
active_private_key: Optional[str] = None
ssh_user: str
sshpass_available: bool
+112
View File
@@ -0,0 +1,112 @@
"""Authentication schemas for login, token, and user management."""
from __future__ import annotations
from datetime import datetime
from typing import Optional
from pydantic import BaseModel, EmailStr, Field, field_validator
class LoginRequest(BaseModel):
"""Request schema for user login."""
username: str = Field(..., min_length=3, max_length=50, description="Username")
password: str = Field(..., min_length=6, description="Password")
class Token(BaseModel):
"""JWT token response."""
access_token: str
token_type: str = "bearer"
expires_in: int = Field(description="Token expiration time in seconds")
class TokenData(BaseModel):
"""Data extracted from JWT token."""
username: Optional[str] = None
user_id: Optional[int] = None
role: Optional[str] = None
# User schemas
class UserBase(BaseModel):
"""Base user schema with common fields."""
username: str = Field(..., min_length=3, max_length=50)
email: Optional[EmailStr] = None
display_name: Optional[str] = Field(None, max_length=100)
role: str = Field(default="admin", description="User role: admin, operator, viewer")
is_active: bool = True
class UserCreate(UserBase):
"""Schema for creating a new user."""
password: str = Field(..., min_length=6, max_length=128, description="Password (min 6 chars)")
@field_validator('password')
@classmethod
def password_strength(cls, v: str) -> str:
"""Validate password has minimum complexity."""
if len(v) < 6:
raise ValueError('Password must be at least 6 characters')
return v
class UserUpdate(BaseModel):
"""Schema for updating user (all fields optional)."""
email: Optional[EmailStr] = None
display_name: Optional[str] = Field(None, max_length=100)
role: Optional[str] = None
is_active: Optional[bool] = None
class PasswordChange(BaseModel):
"""Schema for changing password."""
current_password: str = Field(..., description="Current password")
new_password: str = Field(..., min_length=6, max_length=128, description="New password")
@field_validator('new_password')
@classmethod
def password_strength(cls, v: str) -> str:
if len(v) < 6:
raise ValueError('Password must be at least 6 characters')
return v
class UserOut(BaseModel):
"""Schema for user output (without password)."""
id: int
username: str
email: Optional[str] = None
display_name: Optional[str] = None
role: str
is_active: bool
is_superuser: bool
created_at: datetime
last_login: Optional[datetime] = None
class Config:
from_attributes = True
class UserSetup(BaseModel):
"""Schema for initial admin setup (first user creation)."""
username: str = Field(..., min_length=3, max_length=50)
password: str = Field(..., min_length=6, max_length=128)
email: Optional[EmailStr] = None
display_name: Optional[str] = None
@field_validator('password')
@classmethod
def password_strength(cls, v: str) -> str:
if len(v) < 6:
raise ValueError('Password must be at least 6 characters')
return v
class AuthStatus(BaseModel):
"""Response for auth status check."""
authenticated: bool
user: Optional[UserOut] = None
setup_required: bool = Field(
default=False,
description="True if no users exist and setup is needed"
)
+66
View File
@@ -0,0 +1,66 @@
"""
Schémas Pydantic communs utilisés dans plusieurs modules.
"""
from datetime import datetime, timezone
from typing import Optional, Literal, Dict, Any
from pydantic import BaseModel, Field, ConfigDict
class CommandResult(BaseModel):
"""Résultat d'une commande SSH ou Ansible."""
status: str
return_code: int
stdout: str
stderr: Optional[str] = None
execution_time: Optional[float] = None
timestamp: datetime = Field(default_factory=lambda: datetime.now(timezone.utc))
class LogEntry(BaseModel):
"""Entrée de log (modèle mémoire)."""
id: int = 0
timestamp: datetime = Field(default_factory=lambda: datetime.now(timezone.utc))
level: Literal["DEBUG", "INFO", "WARN", "WARNING", "ERROR"] = "INFO"
message: str
source: Optional[str] = None
host: Optional[str] = None
model_config = ConfigDict(
json_encoders={datetime: lambda v: v.isoformat()}
)
class SystemMetrics(BaseModel):
"""Métriques système du dashboard."""
online_hosts: int = 0
total_tasks: int = 0
success_rate: float = 100.0
uptime: float = 99.9
cpu_usage: float = 0.0
memory_usage: float = 0.0
disk_usage: float = 0.0
class PaginatedResponse(BaseModel):
"""Réponse paginée générique."""
items: list = Field(default_factory=list)
count: int = 0
total_count: int = 0
has_more: bool = False
limit: int = 50
offset: int = 0
class SuccessResponse(BaseModel):
"""Réponse de succès générique."""
success: bool = True
message: str
class ErrorResponse(BaseModel):
"""Réponse d'erreur générique."""
error: str
message: str
details: Optional[Dict[str, Any]] = None
+68
View File
@@ -0,0 +1,68 @@
"""
Schémas Pydantic pour la gestion des groupes Ansible.
"""
from typing import Optional, List
import re
from pydantic import BaseModel, Field, field_validator
class GroupRequest(BaseModel):
"""Requête pour créer un groupe."""
name: str = Field(..., min_length=3, max_length=50, description="Nom du groupe (ex: env_prod, role_web)")
type: str = Field(..., description="Type de groupe: 'env' ou 'role'")
@field_validator('name')
@classmethod
def validate_name(cls, v: str) -> str:
if not re.match(r'^[a-zA-Z0-9_-]+$', v):
raise ValueError('Le nom du groupe ne peut contenir que des lettres, chiffres, tirets et underscores')
return v
@field_validator('type')
@classmethod
def validate_type(cls, v: str) -> str:
if v not in ['env', 'role']:
raise ValueError("Le type doit être 'env' ou 'role'")
return v
class GroupUpdateRequest(BaseModel):
"""Requête pour modifier un groupe."""
new_name: str = Field(..., min_length=3, max_length=50, description="Nouveau nom du groupe")
@field_validator('new_name')
@classmethod
def validate_new_name(cls, v: str) -> str:
if not re.match(r'^[a-zA-Z0-9_-]+$', v):
raise ValueError('Le nom du groupe ne peut contenir que des lettres, chiffres, tirets et underscores')
return v
class GroupDeleteRequest(BaseModel):
"""Requête pour supprimer un groupe."""
move_hosts_to: Optional[str] = Field(default=None, description="Groupe vers lequel déplacer les hôtes")
class GroupResponse(BaseModel):
"""Réponse API pour un groupe."""
name: str
type: str
display_name: str
hosts_count: int = 0
hosts: List[str] = Field(default_factory=list)
class GroupsListResponse(BaseModel):
"""Réponse API pour la liste des groupes."""
groups: List[GroupResponse] = Field(default_factory=list)
env_count: int = 0
role_count: int = 0
class HostGroupsResponse(BaseModel):
"""Réponse API pour les groupes disponibles."""
env_groups: List[str] = Field(default_factory=list)
role_groups: List[str] = Field(default_factory=list)
all_groups: List[str] = Field(default_factory=list)
+27
View File
@@ -0,0 +1,27 @@
"""
Schémas Pydantic pour les health checks.
"""
from typing import Optional
from pydantic import BaseModel
class HealthCheck(BaseModel):
"""Résultat d'un health check sur un hôte."""
host: str
ssh_ok: bool = False
ansible_ok: bool = False
sudo_ok: bool = False
reachable: bool = False
error_message: Optional[str] = None
response_time: Optional[float] = None
cached: bool = False
cache_age: int = 0
class GlobalHealthResponse(BaseModel):
"""Réponse du healthcheck global de l'API."""
status: str = "ok"
service: str = "homelab-automation-api"
timestamp: str
+73
View File
@@ -0,0 +1,73 @@
"""
Schémas Pydantic pour les hôtes - modèles API.
Ces modèles sont utilisés pour les requêtes/réponses API,
distincts des modèles de base de données.
"""
from datetime import datetime, timezone
from typing import Optional, List, Literal
from pydantic import BaseModel, Field, ConfigDict, field_validator
class Host(BaseModel):
"""Modèle complet d'un hôte pour l'API."""
id: str
name: str
ip: str
status: Literal["online", "offline", "warning", "unknown"] = "unknown"
os: str = "Linux"
last_seen: Optional[datetime] = None
created_at: datetime = Field(default_factory=lambda: datetime.now(timezone.utc))
groups: List[str] = Field(default_factory=list)
bootstrap_ok: bool = False
bootstrap_date: Optional[datetime] = None
model_config = ConfigDict(
json_encoders={datetime: lambda v: v.isoformat() if v else None}
)
class HostRequest(BaseModel):
"""Requête de création d'un hôte."""
name: str = Field(..., min_length=3, max_length=100, description="Hostname (ex: server.domain.home)")
ip: Optional[str] = Field(default=None, description="Adresse IP ou hostname (optionnel si hostname résolvable)")
os: str = Field(default="Linux", min_length=3, max_length=50)
ssh_user: Optional[str] = Field(default="root", min_length=1, max_length=50)
ssh_port: int = Field(default=22, ge=1, le=65535)
description: Optional[str] = Field(default=None, max_length=200)
env_group: str = Field(..., description="Groupe d'environnement (ex: env_homelab, env_prod)")
role_groups: List[str] = Field(default_factory=list, description="Groupes de rôles (ex: role_proxmox, role_sbc)")
class HostUpdateRequest(BaseModel):
"""Requête de mise à jour d'un hôte."""
env_group: Optional[str] = Field(default=None, description="Nouveau groupe d'environnement")
role_groups: Optional[List[str]] = Field(default=None, description="Nouveaux groupes de rôles")
ansible_host: Optional[str] = Field(default=None, description="Nouvelle adresse ansible_host")
class HostResponse(BaseModel):
"""Réponse API pour un hôte."""
id: str
name: str
ip: Optional[str] = None
status: str = "unknown"
os: str = "Linux"
last_seen: Optional[datetime] = None
created_at: Optional[datetime] = None
groups: List[str] = Field(default_factory=list)
bootstrap_ok: bool = False
bootstrap_date: Optional[datetime] = None
model_config = ConfigDict(from_attributes=True)
class AnsibleInventoryHost(BaseModel):
"""Hôte de l'inventaire Ansible."""
name: str
ansible_host: str
group: str
groups: List[str] = Field(default_factory=list)
vars: dict = Field(default_factory=dict)
+172
View File
@@ -0,0 +1,172 @@
from __future__ import annotations
from datetime import datetime
from typing import Optional, List, Dict, Any
from pydantic import BaseModel, Field, ConfigDict
class DiskInfo(BaseModel):
"""Informations sur un disque/partition"""
mount_point: str
filesystem: Optional[str] = None
total_gb: float
used_gb: float
free_gb: float
usage_percent: float
class NetworkInterface(BaseModel):
"""Informations sur une interface réseau"""
name: str
ip_address: Optional[str] = None
mac_address: Optional[str] = None
status: Optional[str] = None
class HostMetricsBase(BaseModel):
"""Schéma de base pour les métriques d'hôte"""
metric_type: str = Field(..., description="Type de métrique (system_info, full, etc.)")
# CPU
cpu_count: Optional[int] = None
cpu_model: Optional[str] = None
cpu_cores: Optional[int] = None
cpu_threads: Optional[int] = None
cpu_threads_per_core: Optional[int] = None
cpu_sockets: Optional[int] = None
cpu_mhz: Optional[float] = None
cpu_max_mhz: Optional[float] = None
cpu_min_mhz: Optional[float] = None
cpu_load_1m: Optional[float] = None
cpu_load_5m: Optional[float] = None
cpu_load_15m: Optional[float] = None
cpu_usage_percent: Optional[float] = None
cpu_temperature: Optional[float] = None
# Memory
memory_total_mb: Optional[int] = None
memory_used_mb: Optional[int] = None
memory_free_mb: Optional[int] = None
memory_usage_percent: Optional[float] = None
swap_total_mb: Optional[int] = None
swap_used_mb: Optional[int] = None
swap_usage_percent: Optional[float] = None
# Disk
disk_info: Optional[List[Dict[str, Any]]] = None
disk_devices: Optional[List[Dict[str, Any]]] = None
disk_root_total_gb: Optional[float] = None
disk_root_used_gb: Optional[float] = None
disk_root_usage_percent: Optional[float] = None
# Storage stacks
lvm_info: Optional[Dict[str, Any]] = None
zfs_info: Optional[Dict[str, Any]] = None
# System info
os_name: Optional[str] = None
os_version: Optional[str] = None
kernel_version: Optional[str] = None
hostname: Optional[str] = None
uptime_seconds: Optional[int] = None
uptime_human: Optional[str] = None
# Network
network_info: Optional[List[Dict[str, Any]]] = None
class HostMetricsCreate(HostMetricsBase):
"""Schéma pour créer des métriques"""
host_id: str
raw_data: Optional[Dict[str, Any]] = None
collection_source: Optional[str] = None
collection_duration_ms: Optional[int] = None
error_message: Optional[str] = None
class HostMetricsOut(HostMetricsBase):
"""Schéma de sortie pour les métriques"""
id: int
host_id: str
collected_at: datetime
created_at: datetime
collection_source: Optional[str] = None
collection_duration_ms: Optional[int] = None
error_message: Optional[str] = None
model_config = ConfigDict(from_attributes=True)
class HostMetricsSummary(BaseModel):
"""Résumé des métriques pour affichage dans la carte d'hôte"""
host_id: str
host_name: Optional[str] = None
last_collected: Optional[datetime] = None
# Résumé CPU
cpu_usage_percent: Optional[float] = None
cpu_load_1m: Optional[float] = None
cpu_temperature: Optional[float] = None
cpu_model: Optional[str] = None
cpu_count: Optional[int] = None
cpu_cores: Optional[int] = None
cpu_threads: Optional[int] = None
cpu_max_mhz: Optional[float] = None
# Résumé mémoire
memory_usage_percent: Optional[float] = None
memory_total_mb: Optional[int] = None
memory_used_mb: Optional[int] = None
# Résumé disque (partition racine)
disk_root_usage_percent: Optional[float] = None
disk_root_total_gb: Optional[float] = None
disk_root_used_gb: Optional[float] = None
disk_info: Optional[List[Dict[str, Any]]] = None
disk_devices: Optional[List[Dict[str, Any]]] = None
# Storage stacks
lvm_info: Optional[Dict[str, Any]] = None
zfs_info: Optional[Dict[str, Any]] = None
# Système
os_name: Optional[str] = None
uptime_human: Optional[str] = None
# Statut de la collecte
collection_status: str = "unknown" # success, failed, pending, unknown
error_message: Optional[str] = None
class BuiltinPlaybookDefinition(BaseModel):
"""Définition d'un builtin playbook"""
id: str = Field(..., description="Identifiant unique du builtin playbook")
name: str = Field(..., description="Nom affiché")
description: str = Field(..., description="Description du playbook")
playbook_file: str = Field(..., description="Nom du fichier playbook Ansible")
category: str = Field(..., description="Catégorie (metrics, maintenance, etc.)")
icon: str = Field(default="fas fa-cog", description="Icône FontAwesome")
color: str = Field(default="blue", description="Couleur du bouton")
collect_metrics: bool = Field(default=False, description="Si true, les résultats sont stockés comme métriques")
schedule_enabled: bool = Field(default=True, description="Peut être planifié")
visible_in_ui: bool = Field(default=True, description="Visible dans l'interface")
class BuiltinPlaybookExecutionRequest(BaseModel):
"""Requête d'exécution d'un builtin playbook"""
builtin_id: str = Field(..., description="ID du builtin playbook")
target: str = Field(..., description="Cible (host ou groupe)")
extra_vars: Optional[Dict[str, Any]] = None
class BuiltinPlaybookExecutionResult(BaseModel):
"""Résultat d'exécution d'un builtin playbook"""
success: bool
builtin_id: str
target: str
execution_time: float
metrics_saved: bool = False
hosts_processed: int = 0
error: Optional[str] = None
log_path: Optional[str] = None
+10 -10
View File
@@ -252,7 +252,7 @@ class NotificationTemplates:
details.append(f"• Taille : {size}")
return NotificationRequest(
topic=None,
topic="homelab-backup",
title="✅ Backup terminé avec succès",
message="\n".join(details),
priority=3,
@@ -266,7 +266,7 @@ class NotificationTemplates:
) -> NotificationRequest:
"""Notification d'échec de backup."""
return NotificationRequest(
topic=None,
topic="homelab-backup",
title="❌ Échec du backup",
message=f"• Hôte : {hostname}\n• Erreur : {error}",
priority=5,
@@ -277,18 +277,18 @@ class NotificationTemplates:
def bootstrap_started(hostname: str) -> NotificationRequest:
"""Notification de début de bootstrap."""
return NotificationRequest(
topic=None,
topic="homelab-bootstrap",
title="🔧 Bootstrap en cours",
message=f"Configuration initiale en cours pour l'hôte {hostname}.",
priority=3,
tags=["wrench", "computer"]
tags=["rocket", "wrench", "computer"]
)
@staticmethod
def bootstrap_success(hostname: str) -> NotificationRequest:
"""Notification de succès de bootstrap."""
return NotificationRequest(
topic=None,
topic="homelab-bootstrap",
title="✅ Bootstrap terminé avec succès",
message=f"L'hôte {hostname} est maintenant configuré et prêt pour Ansible.",
priority=3,
@@ -299,7 +299,7 @@ class NotificationTemplates:
def bootstrap_failed(hostname: str, error: str) -> NotificationRequest:
"""Notification d'échec de bootstrap."""
return NotificationRequest(
topic=None,
topic="homelab-bootstrap",
title="❌ Échec du bootstrap",
message=f"• Hôte : {hostname}\n• Erreur : {error}",
priority=5,
@@ -315,16 +315,16 @@ class NotificationTemplates:
"""Notification de changement d'état de santé."""
if new_status == "down":
return NotificationRequest(
topic=None,
title="🔴 Hôte inaccessible",
topic="homelab-health",
title="🔴 Host DOWN",
message=f"L'hôte {hostname} ne répond plus." + (f"\n• Détails : {details}" if details else ""),
priority=5,
tags=["red_circle", "warning"]
)
else:
return NotificationRequest(
topic=None,
title="🟢 Hôte de nouveau accessible",
topic="homelab-health",
title="🟢 Host UP",
message=f"L'hôte {hostname} est de nouveau en ligne." + (f"\n• Détails : {details}" if details else ""),
priority=3,
tags=["green_circle", "white_check_mark"]
+161
View File
@@ -0,0 +1,161 @@
"""
Schémas Pydantic pour les schedules - modèles API complets.
"""
from datetime import datetime, timezone
from typing import Optional, List, Literal, Dict, Any
import uuid
from pydantic import BaseModel, Field, ConfigDict, field_validator
import pytz
class ScheduleRecurrence(BaseModel):
"""Configuration de récurrence pour un schedule."""
type: Literal["daily", "weekly", "monthly", "custom"] = "daily"
time: str = Field(default="02:00", description="Heure d'exécution HH:MM")
days: Optional[List[int]] = Field(default=None, description="Jours de la semaine (1-7, lundi=1) pour weekly")
day_of_month: Optional[int] = Field(default=None, ge=1, le=31, description="Jour du mois (1-31) pour monthly")
cron_expression: Optional[str] = Field(default=None, description="Expression cron pour custom")
class Schedule(BaseModel):
"""Modèle complet d'un schedule pour l'API."""
id: str = Field(default_factory=lambda: f"sched_{uuid.uuid4().hex[:12]}")
name: str = Field(..., min_length=3, max_length=100, description="Nom du schedule")
description: Optional[str] = Field(default=None, max_length=500)
playbook: str = Field(..., description="Nom du playbook à exécuter")
target_type: Literal["group", "host"] = Field(default="group", description="Type de cible")
target: str = Field(default="all", description="Nom du groupe ou hôte cible")
extra_vars: Optional[Dict[str, Any]] = Field(default=None, description="Variables supplémentaires")
schedule_type: Literal["once", "recurring"] = Field(default="recurring")
recurrence: Optional[ScheduleRecurrence] = Field(default=None)
timezone: str = Field(default="America/Montreal", description="Fuseau horaire")
start_at: Optional[datetime] = Field(default=None, description="Date de début (optionnel)")
end_at: Optional[datetime] = Field(default=None, description="Date de fin (optionnel)")
next_run_at: Optional[datetime] = Field(default=None, description="Prochaine exécution calculée")
last_run_at: Optional[datetime] = Field(default=None, description="Dernière exécution")
last_status: Literal["success", "failed", "running", "never"] = Field(default="never")
enabled: bool = Field(default=True, description="Schedule actif ou en pause")
retry_on_failure: int = Field(default=0, ge=0, le=3, description="Nombre de tentatives en cas d'échec")
timeout: int = Field(default=3600, ge=60, le=86400, description="Timeout en secondes")
notification_type: Literal["none", "all", "errors"] = Field(default="all", description="Type de notification")
tags: List[str] = Field(default_factory=list, description="Tags pour catégorisation")
run_count: int = Field(default=0, description="Nombre total d'exécutions")
success_count: int = Field(default=0, description="Nombre de succès")
failure_count: int = Field(default=0, description="Nombre d'échecs")
created_at: datetime = Field(default_factory=lambda: datetime.now(timezone.utc))
updated_at: datetime = Field(default_factory=lambda: datetime.now(timezone.utc))
model_config = ConfigDict(
json_encoders={datetime: lambda v: v.isoformat() if v else None}
)
@field_validator('recurrence', mode='before')
@classmethod
def validate_recurrence(cls, v, info):
return v
class ScheduleRun(BaseModel):
"""Historique d'une exécution de schedule."""
id: str = Field(default_factory=lambda: f"run_{uuid.uuid4().hex[:12]}")
schedule_id: str = Field(..., description="ID du schedule parent")
task_id: Optional[str] = Field(default=None, description="ID de la tâche créée")
started_at: datetime = Field(default_factory=lambda: datetime.now(timezone.utc))
finished_at: Optional[datetime] = Field(default=None)
status: Literal["running", "success", "failed", "canceled"] = Field(default="running")
duration_seconds: Optional[float] = Field(default=None)
hosts_impacted: int = Field(default=0)
error_message: Optional[str] = Field(default=None)
retry_attempt: int = Field(default=0, description="Numéro de la tentative (0 = première)")
model_config = ConfigDict(
json_encoders={datetime: lambda v: v.isoformat() if v else None}
)
class ScheduleCreateRequest(BaseModel):
"""Requête de création d'un schedule."""
name: str = Field(..., min_length=3, max_length=100)
description: Optional[str] = Field(default=None, max_length=500)
playbook: str = Field(...)
target_type: Literal["group", "host"] = Field(default="group")
target: str = Field(default="all")
extra_vars: Optional[Dict[str, Any]] = Field(default=None)
schedule_type: Literal["once", "recurring"] = Field(default="recurring")
recurrence: Optional[ScheduleRecurrence] = Field(default=None)
timezone: str = Field(default="America/Montreal")
start_at: Optional[datetime] = Field(default=None)
end_at: Optional[datetime] = Field(default=None)
enabled: bool = Field(default=True)
retry_on_failure: int = Field(default=0, ge=0, le=3)
timeout: int = Field(default=3600, ge=60, le=86400)
notification_type: Literal["none", "all", "errors"] = Field(default="all")
tags: List[str] = Field(default_factory=list)
@field_validator('timezone')
@classmethod
def validate_timezone(cls, v: str) -> str:
try:
pytz.timezone(v)
return v
except pytz.exceptions.UnknownTimeZoneError:
raise ValueError(f"Fuseau horaire invalide: {v}")
class ScheduleUpdateRequest(BaseModel):
"""Requête de mise à jour d'un schedule."""
name: Optional[str] = Field(default=None, min_length=3, max_length=100)
description: Optional[str] = Field(default=None, max_length=500)
playbook: Optional[str] = Field(default=None)
target_type: Optional[Literal["group", "host"]] = Field(default=None)
target: Optional[str] = Field(default=None)
extra_vars: Optional[Dict[str, Any]] = Field(default=None)
schedule_type: Optional[Literal["once", "recurring"]] = Field(default=None)
recurrence: Optional[ScheduleRecurrence] = Field(default=None)
timezone: Optional[str] = Field(default=None)
start_at: Optional[datetime] = Field(default=None)
end_at: Optional[datetime] = Field(default=None)
enabled: Optional[bool] = Field(default=None)
retry_on_failure: Optional[int] = Field(default=None, ge=0, le=3)
timeout: Optional[int] = Field(default=None, ge=60, le=86400)
notification_type: Optional[Literal["none", "all", "errors"]] = Field(default=None)
tags: Optional[List[str]] = Field(default=None)
class ScheduleStats(BaseModel):
"""Statistiques globales des schedules."""
total: int = 0
active: int = 0
paused: int = 0
expired: int = 0
next_execution: Optional[datetime] = None
next_schedule_name: Optional[str] = None
failures_24h: int = 0
executions_24h: int = 0
success_rate_7d: float = 0.0
class ScheduleListResponse(BaseModel):
"""Réponse API pour la liste des schedules."""
schedules: List[dict] = Field(default_factory=list)
count: int = 0
class UpcomingExecution(BaseModel):
"""Prochaine exécution planifiée."""
schedule_id: str
schedule_name: str
playbook: str
target: str
next_run_at: Optional[str] = None
tags: List[str] = Field(default_factory=list)
class CronValidationResult(BaseModel):
"""Résultat de validation d'une expression cron."""
valid: bool
expression: str
next_runs: Optional[List[str]] = None
error: Optional[str] = None
+117
View File
@@ -0,0 +1,117 @@
"""
Schémas Pydantic pour les tâches - modèles API.
"""
from datetime import datetime, timezone
from typing import Optional, List, Literal, Dict, Any
from pydantic import BaseModel, Field, ConfigDict, field_validator
class Task(BaseModel):
"""Modèle complet d'une tâche pour l'API."""
id: str
name: str
host: str
status: Literal["pending", "running", "completed", "failed", "cancelled"] = "pending"
progress: int = Field(ge=0, le=100, default=0)
start_time: Optional[datetime] = None
end_time: Optional[datetime] = None
duration: Optional[str] = None
output: Optional[str] = None
error: Optional[str] = None
model_config = ConfigDict(
json_encoders={datetime: lambda v: v.isoformat() if v else None}
)
class TaskRequest(BaseModel):
"""Requête de création d'une tâche."""
host: Optional[str] = Field(default=None, description="Hôte cible")
group: Optional[str] = Field(default=None, description="Groupe cible")
action: str = Field(..., description="Action à exécuter")
cmd: Optional[str] = Field(default=None, description="Commande personnalisée")
extra_vars: Optional[Dict[str, Any]] = Field(default=None, description="Variables Ansible")
tags: Optional[List[str]] = Field(default=None, description="Tags Ansible")
dry_run: bool = Field(default=False, description="Mode simulation")
ssh_user: Optional[str] = Field(default=None, description="Utilisateur SSH")
ssh_password: Optional[str] = Field(default=None, description="Mot de passe SSH")
@field_validator('action')
@classmethod
def validate_action(cls, v: str) -> str:
valid_actions = ['upgrade', 'reboot', 'health-check', 'backup', 'deploy', 'rollback', 'maintenance', 'bootstrap']
if v not in valid_actions:
raise ValueError(f'Action doit être l\'une de: {", ".join(valid_actions)}')
return v
class TaskLogFile(BaseModel):
"""Représentation d'un fichier de log de tâche."""
id: str
filename: str
path: str
task_name: str
target: str
status: str
date: str # Format YYYY-MM-DD
year: str
month: str
day: str
created_at: datetime
size_bytes: int
start_time: Optional[str] = None
end_time: Optional[str] = None
duration: Optional[str] = None
duration_seconds: Optional[int] = None
hosts: List[str] = Field(default_factory=list)
category: Optional[str] = None
subcategory: Optional[str] = None
target_type: Optional[str] = None
source_type: Optional[str] = None
class TasksFilterParams(BaseModel):
"""Paramètres de filtrage des tâches."""
status: Optional[str] = None
year: Optional[str] = None
month: Optional[str] = None
day: Optional[str] = None
hour_start: Optional[str] = None
hour_end: Optional[str] = None
target: Optional[str] = None
source_type: Optional[str] = None
search: Optional[str] = None
limit: int = 50
offset: int = 0
class TaskLogsResponse(BaseModel):
"""Réponse API pour les logs de tâches."""
logs: List[dict] = Field(default_factory=list)
count: int = 0
total_count: int = 0
has_more: bool = False
filters: Dict[str, Optional[str]] = Field(default_factory=dict)
pagination: Dict[str, int] = Field(default_factory=dict)
class TaskLogDatesResponse(BaseModel):
"""Structure des dates disponibles pour le filtrage."""
years: Dict[str, Any] = Field(default_factory=dict)
class TaskStatsResponse(BaseModel):
"""Statistiques des tâches."""
total: int = 0
completed: int = 0
failed: int = 0
running: int = 0
pending: int = 0
class RunningTasksResponse(BaseModel):
"""Réponse API pour les tâches en cours."""
tasks: List[dict] = Field(default_factory=list)
count: int = 0