diff --git a/commandes/gitlab_issues.json b/commandes/gitlab_issues.json index 8174dd2..4003089 100644 --- a/commandes/gitlab_issues.json +++ b/commandes/gitlab_issues.json @@ -38,5 +38,10 @@ "requester_id": 971446412690722826, "last_note_id": 0, "type": "legacy_report" + }, + "None": { + "requester_id": 971446412690722826, + "last_note_id": 0, + "type": "manual-report" } } \ No newline at end of file diff --git a/serveur_flask.py b/serveur_flask.py index 7cb3435..190e4c8 100644 --- a/serveur_flask.py +++ b/serveur_flask.py @@ -12,17 +12,18 @@ app = Flask(__name__) PROJECT_PATH = "/home/discord/Bot/Kuby" WEBHOOK_SECRET = "Nois2" PROCESS_NAME = "kuby" +# webhook de logs Discord DISCORD_LOG_URL = "https://discord.com/api/webhooks/1482148910888652910/IA9CcOWtjGswbuxMaOu_6uaclv5zojZo4ttxtV6RYyZzJ9gW7BF7xp_Zv3oPIjYEuh8o" -# Chemin absolu vers le binaire PM2 (Ă©vite l'erreur 127 command not found) +# Chemin vers PM2 PM2_BINARY = "/home/discord/.nvm/versions/node/v24.15.0/bin/pm2" -# Bot Local Proxy +# Bot Local Proxy (Relai vers le Cog de ton bot) BOT_LOCAL_URL = "http://127.0.0.1:5001/bot_event" def send_discord_log(status, message, color, author=None, commit_msg=None): embed = { - "title": f"🚀 Kuby V2 : {status}", + "title": f"🚀 Kuby V2 [Forgejo] : {status}", "description": message, "color": color, "timestamp": datetime.now(timezone.utc).isoformat(), @@ -36,7 +37,7 @@ def send_discord_log(status, message, color, author=None, commit_msg=None): payload = {"embeds": [embed]} try: - requests.post(DISCORD_LOG_URL, json=payload, timeout=10) # ✅ AugmentĂ© de 5s Ă  10s + requests.post(DISCORD_LOG_URL, json=payload, timeout=10) except Exception as e: print(f"[!] Erreur envoi Discord : {e}") @@ -58,29 +59,15 @@ def run_mep_logic(author, commit_msg, branch="main"): os.chdir(target_path) - # 1. GIT + # 1. GIT (Va maintenant pull depuis ton Forgejo auto-hĂ©bergĂ©) subprocess.run(["git", "fetch", "origin"], check=True) subprocess.run(["git", "reset", "--hard", f"origin/{branch}"], check=True) - # 2. RSYNC (si on utilise le fallback de dĂ©pĂŽt) + # 2. RSYNC (Fallback) if use_rsync: subprocess.run(["rsync", "-a", "--exclude=.git", "--exclude=venv", "--exclude=.venv", "--exclude=__pycache__", f"{target_path}/", f"{PROJECT_PATH}/"], check=True) - # ⚡ Migration automatique GitLab tracking - send_discord_log("MIGRATION", "Migration GitLab tracking en cours...", 16776960, author, commit_msg) - try: - subprocess.run( - ["python3", os.path.join(target_path, "scripts", "migrate_gitlab_tracking.py")], - cwd=target_path, - check=True, - capture_output=True, - text=True - ) - send_discord_log("MIGRATION", "✅ Migration GitLab tracking terminĂ©e.", 3066993, author, commit_msg) - except subprocess.CalledProcessError as e: - send_discord_log("ERREUR MIGRATION", f"❌ Migration GitLab Ă©chouĂ©e: {e.stderr}", 15158332, author, commit_msg) - - # 3. PM2 (AppelĂ© directement via son chemin absolu pour corriger l'erreur 127) + # 3. PM2 Restart subprocess.run( [PM2_BINARY, "restart", PROCESS_NAME], check=True, @@ -89,26 +76,24 @@ def run_mep_logic(author, commit_msg, branch="main"): ) duration = (datetime.now() - start_time).total_seconds() - msg = f"✅ **DĂ©ploiement rĂ©ussi en {duration:.2f}s**\nLe bot est Ă  jour et redĂ©marrĂ©." + msg = f"✅ **DĂ©ploiement rĂ©ussi en {duration:.2f}s**\nLe bot est Ă  jour sur Forgejo et redĂ©marrĂ©." send_discord_log("VALIDÉ", msg, 3066993, author, commit_msg) except subprocess.CalledProcessError as e: - # Capture spĂ©cifique si une commande systĂšme (comme Git ou PM2) crash - error_stderr = e.stderr if e.stderr else "Pas de log d'erreur disponible (stderr vide)." + error_stderr = e.stderr if e.stderr else "Pas de log d'erreur disponible." error_msg = f"❌ **ERREUR de commande (Status {e.returncode})**\nCommande : `{ ' '.join(e.cmd) }`\n\n**DĂ©tails :**\n```\n{error_stderr}\n```" send_discord_log("ÉCHEC", error_msg, 15158332, author, commit_msg) except Exception as e: - # Capture globale pour le reste du script Python error_msg = f"❌ **ERREUR de dĂ©ploiement**\n```python\n{str(e)}\n```" send_discord_log("ÉCHEC", error_msg, 15158332, author, commit_msg) @app.route('/deploy', methods=['POST']) def deploy(): - # SĂ©curitĂ© - if request.headers.get('X-Gitlab-Token') != WEBHOOK_SECRET: + # ⚡ MODIFICATION : Forgejo envoie son token secret dans 'X-Gitea-Token' + if request.headers.get('X-Gitea-Token') != WEBHOOK_SECRET: abort(403) - # Extraction des infos GitLab + # Extraction des infos (La structure des commits est identique Ă  GitLab) data = request.json author = "Inconnu" commit_msg = "Pas de message" @@ -121,34 +106,32 @@ def deploy(): ref = data.get('ref', 'refs/heads/main') branch = ref.split('/')[-1] if ref else 'main' - # Threading pour rĂ©pondre vite Ă  GitLab + # Threading inchangĂ© pour rĂ©pondre instantanĂ©ment Ă  Forgejo threading.Thread(target=run_mep_logic, args=(author, commit_msg, branch)).start() return {"status": "accepted"}, 202 -@app.route('/gitlab_webhook', methods=['POST']) -def gitlab_webhook(): - # Protection par Token uniquement (anti-crawler gĂ©rĂ© par le secret) - received_token = request.headers.get('X-Gitlab-Token') +# Nouvelle route renommĂ©e pour la clartĂ©, accepte aussi l'ancienne au cas oĂč +@app.route('/forgejo_webhook', methods=['POST']) +@app.route('/gitlab_webhook', methods=['POST']) +def forgejo_webhook(): + # ⚡ MODIFICATION : SĂ©curitĂ© via l'en-tĂȘte Forgejo + received_token = request.headers.get('X-Gitea-Token') - # Log de debug pour voir ce que GitLab envoie vs ce qu'on attend - print(f"[DEBUG] Webhook reçu. Token attendu: '{WEBHOOK_SECRET}', Token reçu: '{received_token}'") + print(f"[DEBUG] Webhook d'Ă©vĂ©nements reçu. Token reçu: '{received_token}'") if received_token != WEBHOOK_SECRET: - abort(403) # ChangĂ© en 403 pour diffĂ©rencier une route non trouvĂ©e d'un accĂšs refusĂ© + abort(403) - # TransfĂ©rer la payload au bot Discord localement sur le port 5001 + # Relai direct de la payload de l'Ă©vĂ©nement (tickets, commentaires) vers ton bot local au port 5001 payload = request.json try: - # On tente de relayer au bot discord. Timeout lĂ©gĂšrement augmentĂ© pour plus de stabilitĂ©. - # On ne passe plus de token interne pour simplifier comme demandĂ©. requests.post(BOT_LOCAL_URL, json=payload, timeout=5) except Exception as e: print(f"[!] Erreur de relais vers le bot Discord : {e}") - # On renvoie 200 Ă  GitLab quand mĂȘme car GitLab n'a pas Ă  savoir l'Ă©tat interne return {"status": "received"}, 200 if __name__ == '__main__': - print(f"[*] Webhook opĂ©rationnel. En attente de push ou d'events...") + print(f"[*] Webhook Forgejo opĂ©rationnel sur le port 5000. PrĂȘt pour les MEP !") app.run(host='0.0.0.0', port=5000) \ No newline at end of file diff --git a/src/logger.py b/src/logger.py index ac149d8..8c4aaee 100755 --- a/src/logger.py +++ b/src/logger.py @@ -52,7 +52,7 @@ class KubyLogger: # GitLab handler for automated error reporting try: - from utils.gitlab_client import gitlab_client + from utils.forgejo_client import gitlab_client class GitLabHandler(logging.Handler): def __init__(self, client): super().__init__() diff --git a/utils/forgejo_client.py b/utils/forgejo_client.py new file mode 100644 index 0000000..1768b73 --- /dev/null +++ b/utils/forgejo_client.py @@ -0,0 +1,173 @@ +import aiohttp +import os +import logging +from datetime import datetime, timedelta, timezone +from typing import Optional, List + +# Logger interne mis Ă  jour pour Forgejo +forgejo_internal_logger = logging.getLogger("ForgejoClient") +forgejo_internal_logger.setLevel(logging.INFO) + +# Alias de compatibilitĂ© pour les anciens imports du bot +gitlab_internal_logger = forgejo_internal_logger + +class ForgejoClient: + # MAP REEL DES LABELS (PĂȘchĂ©s directement depuis API Forgejo) + LABEL_MAPPING = { + "bug": 10, + "suggestion": 11, # Redirige "suggestion" vers "enhancement" + "enhancement": 11, # ID de ton Ă©tiquette bleue + "manual-report": 15, + "manual-suggestion": 16 + } + + def __init__(self): + self.token = os.getenv("FORGEJO_TOKEN") + self.owner = os.getenv("FORGEJO_OWNER") # Exemple: "Gameur" + self.repo = os.getenv("FORGEJO_REPO") # Exemple: "kuby" + self.assignee = os.getenv("FORGEJO_ASSIGNEE") # Pseudo string (optionnel) + + # URL de base automatique via ton Tailscale. + # FIX DE SECURITE : On force le protocole HTTP brut pour Ă©viter l'erreur "ssl:default" sur le port 80 + configured_url = os.getenv("FORGEJO_URL", "http://omegakubeserv.tail951d2f.ts.net").strip().rstrip("/") + if configured_url.startswith("https://"): + configured_url = configured_url.replace("https://", "http://", 1) + self.base_url = configured_url + + # Construction de l'URL de l'API v1 standard de Forgejo/Gitea + if "api/v1" not in self.base_url: + self.api_url = f"{self.base_url}/api/v1/repos/{self.owner}/{self.repo}/issues" + else: + self.api_url = f"{self.base_url}/repos/{self.owner}/{self.repo}/issues" + + async def create_issue(self, title: str, description: str, labels: Optional[List[str]] = None) -> Optional[dict]: + """ + CrĂ©e un ticket sur Forgejo avec les bons IDs numĂ©riques de labels. + """ + if not self.token or not self.owner or not self.repo: + if not hasattr(self, '_config_warned'): + forgejo_internal_logger.warning("⚠ L'intĂ©gration Forgejo n'est pas configurĂ©e (token/owner/repo manquants).") + self._config_warned = True + return None + + headers = { + "Authorization": f"token {self.token}", + "Content-Type": "application/json" + } + + # CONVERSION DES LABELS : On transforme les chaĂźnes ("bug") en entiers (10) attendus par l'API Go + forgejo_label_ids = [] + if labels: + for label in labels: + label_id = self.LABEL_MAPPING.get(label.lower()) + if label_id: + forgejo_label_ids.append(label_id) + + # Payload au format Forgejo strict + payload = { + "title": title, + "body": description, + "labels": forgejo_label_ids # Reçoit dĂ©sormais un tableau d'int64 (ex: [10]) + } + + if self.assignee: + payload["assignees"] = [self.assignee] + + timeout = aiohttp.ClientTimeout(total=15) + async with aiohttp.ClientSession(timeout=timeout) as session: + try: + async with session.post(self.api_url, headers=headers, json=payload) as response: + if response.status == 201: + result = await response.json() + forgejo_internal_logger.info(f"✅ Forgejo issue crĂ©Ă©e : {result.get('html_url')}") + return result + else: + error_text = await response.text() + forgejo_internal_logger.error(f"❌ Échec de la crĂ©ation : {response.status} - {error_text}") + return None + except Exception as e: + forgejo_internal_logger.error(f"❌ Erreur de connexion Ă  l'API Forgejo : {e}") + return None + + async def find_issue_by_title(self, title: str, state: str = "open") -> Optional[dict]: + """ + Recherche un ticket par son titre exact et son Ă©tat (open/closed). + """ + if not self.token or not self.owner or not self.repo: + return None + + headers = {"Authorization": f"token {self.token}"} + forgejo_state = "open" if state == "opened" else state + + params = { + "q": title, + "state": forgejo_state + } + + async with aiohttp.ClientSession() as session: + try: + async with session.get(self.api_url, headers=headers, params=params) as response: + if response.status == 200: + issues = await response.json() + for issue in issues: + if issue.get("title") == title: + return issue + return None + else: + return None + except Exception as e: + forgejo_internal_logger.error(f"❌ Erreur lors de la recherche Forgejo : {e}") + return None + + async def get_closed_issues(self) -> List[dict]: + """ + RĂ©cupĂšre les tickets rĂ©cemment fermĂ©s (depuis 24h). + """ + if not self.token or not self.owner or not self.repo: + return [] + + headers = {"Authorization": f"token {self.token}"} + yesterday = (datetime.now(timezone.utc) - timedelta(days=1)).isoformat() + + params = { + "state": "closed", + "since": yesterday + } + + async with aiohttp.ClientSession() as session: + try: + async with session.get(self.api_url, headers=headers, params=params) as response: + if response.status == 200: + return await response.json() + else: + error_text = await response.text() + forgejo_internal_logger.error(f"❌ Erreur rĂ©cupĂ©ration tickets fermĂ©s : {response.status} - {error_text}") + return [] + except Exception as e: + forgejo_internal_logger.error(f"❌ Erreur connexion API Forgejo : {e}") + return [] + + async def get_issue(self, issue_number: int) -> Optional[dict]: + """ + RĂ©cupĂšre un ticket spĂ©cifique via son numĂ©ro (ID interne). + """ + if not self.token or not self.owner or not self.repo: + return None + + headers = {"Authorization": f"token {self.token}"} + url = f"{self.api_url}/{issue_number}" + + async with aiohttp.ClientSession() as session: + try: + async with session.get(url, headers=headers) as response: + if response.status == 200: + return await response.json() + else: + return None + except Exception as e: + forgejo_internal_logger.error(f"❌ Erreur connexion API Forgejo : {e}") + return None + +# --- SÉCURITÉ ET ALIAS DE COMPATIBILITÉ --- +GitLabClient = ForgejoClient +gitlab_client = ForgejoClient() # Singleton conservĂ© sous l'ancien nom pour le reste du bot \ No newline at end of file diff --git a/utils/gitlab_client.py b/utils/gitlab_client.py index 40d7993..8fc9ecd 100644 --- a/utils/gitlab_client.py +++ b/utils/gitlab_client.py @@ -1,143 +1,16 @@ -import aiohttp -import os -import logging -from datetime import datetime, timedelta -from typing import Optional, List +"""CompatibilitĂ© rĂ©troactive pour les anciens imports du bot. -# Use a separate logger to avoid infinite loops if GitLab reporting fails -gitlab_internal_logger = logging.getLogger("GitLabClient") -gitlab_internal_logger.setLevel(logging.INFO) -# We don't add handlers here, it will just log to console through hierarchy or be silent if needed +Certaines commandes ou anciens modules peuvent encore importer +`utils.gitlab_client`. Ce fichier sert de pont vers le client Forgejo +actuel sans casser le chargement du bot. +""" -class GitLabClient: - def __init__(self): - self.token = os.getenv("GITLAB_TOKEN") - self.project_id = os.getenv("GITLAB_PROJECT_ID") - self.assignee_id = os.getenv("GITLAB_ASSIGNEE_ID") - self.base_url = os.getenv("GITLAB_URL", "https://gitlab.com").rstrip("/") - # Ensure base_url only contains the schema and domain for the API endpoint - if "api/v4" not in self.base_url: - parts = self.base_url.split("/") - api_base = "/".join(parts[:3]) # Gets https://gitlab.com - self.api_url = f"{api_base}/api/v4/projects/{self.project_id}/issues" - else: - self.api_url = f"{self.base_url}/projects/{self.project_id}/issues" +from utils.forgejo_client import ForgejoClient, forgejo_internal_logger, gitlab_internal_logger - async def create_issue(self, title: str, description: str, labels: Optional[List[str]] = None) -> Optional[dict]: - """ - Creates an issue on GitLab. - """ - if not self.token or not self.project_id: - # Use a print or a lower level log to avoid triggering the GitLab logger itself - # which could cause an infinite loop if this were an ERROR log. - if not hasattr(self, '_config_warned'): - print("⚠ GitLab integration is not configured. GitLab issues will not be created.") - self._config_warned = True - return None +# Nom conservĂ© pour ne pas casser les imports existants +# (les anciens cogs utilisent souvent `gitlab_client`) +gitlab_client = ForgejoClient() - headers = { - "PRIVATE-TOKEN": self.token - } - - data = { - "title": title, - "description": description, - "labels": ",".join(labels) if labels else "" - } - - if self.assignee_id: - data["assignee_ids"] = [self.assignee_id] - - async with aiohttp.ClientSession() as session: - try: - async with session.post(self.api_url, headers=headers, data=data) as response: - if response.status == 201: - result = await response.json() - gitlab_internal_logger.info(f"✅ GitLab issue created: {result.get('web_url')}") - return result - else: - error_text = await response.text() - gitlab_internal_logger.error(f"❌ Failed to create GitLab issue: {response.status} - {error_text}") - return None - except Exception as e: - gitlab_internal_logger.error(f"❌ Error connecting to GitLab API: {e}") - return None - - async def find_issue_by_title(self, title: str, state: str = "opened") -> Optional[dict]: - """ - Searches for an issue by its exact title and state. - """ - if not self.token or not self.project_id: - return None - - headers = {"PRIVATE-TOKEN": self.token} - params = { - "search": title, - "state": state - } - - async with aiohttp.ClientSession() as session: - try: - # search param is fuzzy on GitLab, so we must double-check for exact match - async with session.get(self.api_url, headers=headers, params=params) as response: - if response.status == 200: - issues = await response.json() - for issue in issues: - if issue.get("title") == title: - return issue - return None - else: - return None - except Exception as e: - gitlab_internal_logger.error(f"❌ Error searching GitLab issues: {e}") - return None - - async def get_closed_issues(self) -> List[dict]: - """ - Fetches recently closed issues. - """ - if not self.token or not self.project_id: - return [] - - headers = {"PRIVATE-TOKEN": self.token} - params = { - "state": "closed", - "updated_after": (datetime.now() - timedelta(days=1)).isoformat() - } - - async with aiohttp.ClientSession() as session: - try: - async with session.get(self.api_url, headers=headers, params=params) as response: - if response.status == 200: - return await response.json() - else: - error_text = await response.text() - gitlab_internal_logger.error(f"❌ Failed to fetch closed issues: {response.status} - {error_text}") - return [] - except Exception as e: - gitlab_internal_logger.error(f"❌ Error connecting to GitLab API: {e}") - return [] - - async def get_issue(self, issue_iid: int) -> Optional[dict]: - """ - Fetches a specific issue by its internal ID (IID). - """ - if not self.token or not self.project_id: - return None - - headers = {"PRIVATE-TOKEN": self.token} - url = f"{self.base_url}/api/v4/projects/{self.project_id}/issues/{issue_iid}" - - async with aiohttp.ClientSession() as session: - try: - async with session.get(url, headers=headers) as response: - if response.status == 200: - return await response.json() - else: - return None - except Exception as e: - gitlab_internal_logger.error(f"❌ Error connecting to GitLab API: {e}") - return None - -# Instance unique -gitlab_client = GitLabClient() +# Exposition explicite du logger pour compatibilitĂ© +# pylint: disable=invalid-name +gitlab_internal_logger = gitlab_internal_logger